Какой тип имеет литерал 0x0bp3

Литералы

Целочисленные литералы — самый используемый тип в программах. Любое целочисленное значение является числовым литералом, т.е. значения 1, 5, 9, 42 и т.п. являются числовыми литералами с основанием 10. Также можно использовать восьмеричные и шестнадцатиричные значения.

Восьмиричные значения обозначаются ведущим нулем (обычные десятичные числа не могут иметь ведущий нуль). По этой причине с виду нормальное число 09 вызовет ошибку компиляции, так как выйдет за пределы диапазона от 0 до 7 допустимых восьмеричных значений.

Шестнадцатиричные значения обозначают ведущим нулём и символом x (икс). Можно использовать маленький (0x) и большой (0X) символ в числах. Диапазон допустимых цифр — от 0 до 15, где цифры от 10 до 15 заменяются буквами от A до F (можно также использовать символы от a до f в нижнем регистре).

Целочисленные литералы создают значения типа int. Если вы создали переменную типа byte или long, а значение литерала находится в диапазоне допустимых значений этих типов, то ошибки не возникает. Не возникает проблем и с типом long, у которого диапазон значений всегда больше, чем у int. Но при этом нужно явно указать, что значение литерала имеет тип long при помощи строчной или прописной буквы L. Например, 899888777666555444333L.

Целочисленное значение можно также присвоить типу char, если оно лежит в допустимых пределах.

Литералы с плавающей точкой

Числа с плавающей точкой представляют десятичные значения с дробной частью. Число можно записать в двух вариантах — в стандартной и научной форме записи. Стандартная форма — целое число, за которым следуют десятичная точка и дробная часть (например, 3.14). Научная форма записи использует стандартную форму записи числа с плавающей точкой, к которой добавлен суффикс, указывающий степенную функцию числа 10, на которую нужно умножить данное число. Для указания экспоненциальной функции используют символ E или e, за которыми следует десятичное число (положительное или отрицательное). Например, 5.07E12.

По умолчанию литералам с плавающей точкой присвоен тип double. Если вам нужен тип float, то нужно дописать символ F или f. Кстати, для double можно использовать суффиксы D или d, но в этом нет необходимости.

Также возможна запись шестнадцатиричных литерал с плавающей точкой, но на практике я не встречал подобную запись. В этом случае вместо E используется P (или p) — 0x14.3p2.

Символьные литералы

В Java символы представляют собой 16-битовые значения в наборе символов Unicode. Эти значения можно преобразовать в целые значения и применить операции сложения и вычитания. Символьные литералы обрамляются одинарными кавычками. Обычные символы можно ввести стандартным способом, например, ‘c’, ‘a’, ‘@’. Существуют также символы, которые следует экранировать обратным слешем, например, чтобы вывести сам символ одинарной кавычки, нужно использовать вариант ‘\n». Для символа новой строки используется ‘\n’.

Можно вывести нужный символ, используя его восьмеричное или шестнадцатиричное значение. При восьмеричной форме используют обратный слеш, за которым следует трёхзначный номер — ‘\143’.

Для ввода шестнадцатиричного значения используют обратный слеш, символ u, за которыми следуют четыре шестнадцатиричные цифры, например, ‘\u0061’.

Строковые литералы

Строковые литералы — это набор символов в двойных кавычках, например, «Кот — это муж кошки». Внутри строковых литералов также можно использовать управляющие символы, например, для перевода на новую строку — «Кот\nКошка\nКотёнок».

Булевы литералы

Есть только два булевых литерала — true и false. В отличие от некоторых языков программирования, эти значения не преобразуются в числовые значения. При этом литерал true не равен 1, а литерал false не равен 0.

JDK 7

Раньше Android не поддерживал JDK 7. Сейчас поддержка имеется и стали доступны новые возможности.

В JDK 7 можно использовать целочисленные литералы в двоичной системе. Для этого нужно использовать префикс 0b или 0B:

 int x = 0b1010; 

Кроме того, в JDK 7 можно вставлять символы подчёркивания для облегчения чтения больших числовых литералов:

 int x = 123_456_789; double num = 8_343_398.0; 

Символы подчёркивания будут проигнорированы компилятором. Учтите, что можно использовать несколько подряд символов подчёркивания, но нельзя использовать символы подчёркивания в начале или в конце литерала.

Подобная запись удобна при записи вручную программистом номеров телефонов и тому подобных вещей, чтобы визуально лучше анализировать значения. А умная железка сама разберётся, что к чему и не будет удивляться символам подчёркивания в числах.

7. Java – Примитивные и ссылочные типы данных, литералы

Переменные не что иное как зарезервированные места памяти для хранения значений. Это означает, что при создании переменной Вы резервируете некоторое пространство в памяти.

Основываясь на типе данных, который присвоен переменной, операционная система выделяет память и решает, что может быть сохранено в зарезервированную памяти. Поэтому, назначая различные типы данных для переменных, в Java можно хранить целые числа, десятичные дроби или символов в этих переменных.

Существует два типа данных в Java:

• простые или примитивные типы данных;
• ссылочные типы данных (ссылка/объект).

Примитивные типы данных

Существует 8 типов данных, поддерживаемых Java. Основные типы данных предопределены языком и названы по ключевому слову. Теперь давайте посмотрим в деталях эти восемь базовых типов данных существующих в языке программирования Java.

Тип byte

• Тип данных byte является 8-разрядным знаковым целым числом.
• Минимальная величина равна -128 (-2 7 ).
• Максимальное значение равно 127 (включительно) (2 7 -1).
• По умолчанию – 0.
• byte предназначен для экономии места в больших массивах, главным образом вместо целых чисел, поскольку byte в четыре раза меньше, чем int.
• Пример:

byte a = 100; byte b = -50;

Тип short

• Тип данных short является 16-разрядным знаковым целым числом.
• Минимальное значение равно -32768 (-2 15 ).
• Максимальная величина равна 32 767 (включительно) (2 15 -1).
• Тип short в Java может также использоваться для экономии памяти как byte. Размер short в 2 раза меньше, чем int.
• По умолчанию – 0.
• Пример:

short s = 10000; short r = -20000;

Тип int

• В языке Java тип данных int является 32-разрядным знаковым целым числом.
• Минимальный размер int – 2 147 483 648 (-2 31 ).
• Максимальная величина равна 2,147,483,647 (включительно)(2 31 -1).
• Тип int обычно используется для целых значений. Если нет озабоченности по поводу памяти.
• По умолчанию равно 0.
• Пример:

int a = 100000; int b =-200000;

Тип long

• Тип данных long является 64-разрядным знаковым целым числом.
• Минимальное значение равно – 9,223,372,036,854,775,808 (-2 63 ).
• Максимальная величина – 9,223,372,036,854,775,807 (включительно). (2 63 -1).
• В Java Применяется когда требуется более широкий диапазон, чем int.
• По умолчанию – 0L.
• Пример:

long a = 100000L; long b =-200000L;

Тип float

• Тип данных float является c одинарной точностью 32-битный IEEE 754 с плавающей точкой.
• Тип float используется главным образом для сохранения памяти в больших массивах чисел с плавающей точкой.
• По умолчанию – 0.0f.
• Тип float никогда не должен применяется для точного значения, например, валюты.
• Пример:

float f1 = 234.5f;

Тип double

• Тип данных double является c двойной точностью 64-битный IEEE 754 с плавающей точкой.
• Обычно используется для десятичных значений.
• Тип double никогда не должен применяется для точного значения, например, валюты.
• По умолчанию – 0.0d.
• Пример:

double d1 = 123.4;

Тип boolean

• Тип данных boolean представляет собой один бит информации.
• Существует только два возможных значения: true и false.
• Предназначен для простых признаков, которые позволяют отслеживать условия true или false.
• По умолчанию – false.
• Пример:

boolean one = true;

Тип char

• Тип данных char является одним 16-разрядным символом Юникода.
• Минимальная величина равна «\u0000» (или 0).
• Максимальная величина равна «\uffff» (или 65535 включительно).
• В Java char нужен для хранения любого символа.
• Пример:

char letterA ='A';

Ссылочные типы данных

• Ссылочные переменные создаются с использованием определенных конструкторов классов. Они предназначены для доступа к объектам. Эти переменные объявляются с определенным типом, который не может быть изменен. Например, Employee, Puppy и т.д.
• Объекты класса и различные виды переменных массива подпадают под ссылочный тип данных.
• По умолчанию в Java значение любой переменной ссылки — null.
• Ссылочная переменная может применяться для обозначения любого объекта, объявленного или любого совместимого типа.
• Пример:

Animal animal = new Animal("giraffe");

Литералы в Java

Литерал – представление исходного кода как фиксированное значение. Оно представлено непосредственно в коде без каких-либо вычислений.

Литерал в Java можно назначить любой переменной из основного типа. Например:

byte a = 68; char a = 'A';

Byte, int, long, и short может выражаться десятичной (основание 10), шестнадцатеричной (основание 16) или восьмеричной (основание 8) системой исчисления.

При использовании литералов в Java, префикс 0 применяться для указания восьмеричной системы, а префикс 0x указывает на шестнадцатеричную систему. Например:

int decimal = 100; int octal = 0144; int hexa = 0x64;

Строковые литералы в языке Java задаются как и в большинстве других языков, заключив последовательность символов между парой двойных кавычек. Примеры строковых литералов:

"Hello World" "two\nlines" "\"This is in quotes\""

Типы литералов String и char могут содержать любые символы Юникода. Например:

char a = '\u0001'; String a = "\u0001";

Язык Java поддерживает несколько специальных управляющих последовательностей для литералов String и char:

Более подробно управляющие последовательности с примерами рассмотрим в следующих уроках.

Следующий урок объясняет различные типы переменных и их использование. Это даст Вам хорошее представление о том, как они могут использоваться в java-классах, интерфейсах и т.д.

Оглавление

• 1. Java – Самоучитель для начинающих
• 2. Java – Обзор языка
• 3. Java – Установка и настройка
• 4. Java – Синтаксис
• 5. Java – Классы и объекты
• 6. Java – Конструкторы
• 7. Java – Типы данных и литералы
• 8. Java – Типы переменных
• 9. Java – Модификаторы
• 10. Java – Операторы
• 11. Java – Циклы и операторы цикла
• 11.1. Java – Цикл while
• 11.2. Java – Цикл for
• 11.3. Java – Улучшенный цикл for
• 11.4. Java – Цикл do..while
• 11.5. Java – Оператор break
• 11.6. Java – Оператор continue
• 12. Java – Операторы принятия решений
• 12.1. Java – Оператор if
• 12.2. Java – Оператор if..else
• 12.3. Java – Вложенный оператор if
• 12.4. Java – Оператор switch..case
• 12.5. Java – Условный оператор (? 🙂
• 13. Java – Числа
• 13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
• 13.2. Java – Метод compareTo()
• 13.3. Java – Метод equals()
• 13.4. Java – Метод valueOf()
• 13.5. Java – Метод toString()
• 13.6. Java – Метод parseInt()
• 13.7. Java – Метод Math.abs()
• 13.8. Java – Метод Math.ceil()
• 13.9. Java – Метод Math.floor()
• 13.10. Java – Метод Math.rint()
• 13.11. Java – Метод Math.round()
• 13.12. Java – Метод Math.min()
• 13.13. Java – Метод Math.max()
• 13.14. Java – Метод Math.exp()
• 13.15. Java – Метод Math.log()
• 13.16. Java – Метод Math.pow()
• 13.17. Java – Метод Math.sqrt()
• 13.18. Java – Метод Math.sin()
• 13.19. Java – Метод Math.cos()
• 13.20. Java – Метод Math.tan()
• 13.21. Java – Метод Math.asin()
• 13.22. Java – Метод Math.acos()
• 13.23. Java – Метод Math.atan()
• 13.24. Java – Метод Math.atan2()
• 13.25. Java – Метод Math.toDegrees()
• 13.26. Java – Метод Math.toRadians()
• 13.27. Java – Метод Math.random()
• 14. Java – Символы
• 14.1. Java – Метод Character.isLetter()
• 14.2. Java – Метод Character.isDigit()
• 14.3. Java – Метод Character.isWhitespace()
• 14.4. Java – Метод Character.isUpperCase()
• 14.5. Java – Метод Character.isLowerCase()
• 14.6. Java – Метод Character.toUpperCase()
• 14.7. Java – Метод Character.toLowerCase()
• 14.8. Java – Метод Character.toString()
• 15. Java – Строки
• 15.1. Java – Метод charAt()
• 15.2. Java – Метод compareTo()
• 15.3. Java – Метод compareToIgnoreCase()
• 15.4. Java – Метод concat()
• 15.5. Java – Метод contentEquals()
• 15.6. Java – Метод copyValueOf()
• 15.7. Java – Метод endsWith()
• 15.8. Java – Метод equals()
• 15.9. Java – Метод equalsIgnoreCase()
• 15.10. Java – Метод getBytes()
• 15.11. Java – Метод getChars()
• 15.12. Java – Метод hashCode()
• 15.13. Java – Метод indexOf()
• 15.14. Java – Метод intern()
• 15.15. Java – Метод lastIndexOf()
• 15.16. Java – Метод length()
• 15.17. Java – Метод matches()
• 15.18. Java – Метод regionMatches()
• 15.19. Java – Метод replace()
• 15.20. Java – Метод replaceAll()
• 15.21. Java – Метод replaceFirst()
• 15.22. Java – Метод split()
• 15.23. Java – Метод startsWith()
• 15.24. Java – Метод subSequence()
• 15.25. Java – Метод substring()
• 15.26. Java – Метод toCharArray()
• 15.27. Java – Метод toLowerCase()
• 15.28. Java – Метод toString()
• 15.29. Java – Метод toUpperCase()
• 15.30. Java – Метод trim()
• 15.31. Java – Метод valueOf()
• 15.32. Java – Классы StringBuilder и StringBuffer
• 15.32.1. Java – Метод append()
• 15.32.2. Java – Метод reverse()
• 15.32.3. Java – Метод delete()
• 15.32.4. Java – Метод insert()
• 15.32.5. Java – Метод replace()
• 16. Java – Массивы
• 17. Java – Дата и время
• 18. Java – Регулярные выражения
• 19. Java – Методы
• 20. Java – Потоки ввода/вывода, файлы и каталоги
• 20.1. Java – Класс ByteArrayInputStream
• 20.2. Java – Класс DataInputStream
• 20.3. Java – Класс ByteArrayOutputStream
• 20.4. Java – Класс DataOutputStream
• 20.5. Java – Класс File
• 20.6. Java – Класс FileReader
• 20.7. Java – Класс FileWriter
• 21. Java – Исключения
• 21.1. Java – Встроенные исключения
• 22. Java – Вложенные и внутренние классы
• 23. Java – Наследование
• 24. Java – Переопределение
• 25. Java – Полиморфизм
• 26. Java – Абстракция
• 27. Java – Инкапсуляция
• 28. Java – Интерфейсы
• 29. Java – Пакеты
• 30. Java – Структуры данных
• 30.1. Java – Интерфейс Enumeration
• 30.2. Java – Класс BitSet
• 30.3. Java – Класс Vector
• 30.4. Java – Класс Stack
• 30.5. Java – Класс Dictionary
• 30.6. Java – Класс Hashtable
• 30.7. Java – Класс Properties
• 31. Java – Коллекции
• 31.1. Java – Интерфейс Collection
• 31.2. Java – Интерфейс List
• 31.3. Java – Интерфейс Set
• 31.4. Java – Интерфейс SortedSet
• 31.5. Java – Интерфейс Map
• 31.6. Java – Интерфейс Map.Entry
• 31.7. Java – Интерфейс SortedMap
• 31.8. Java – Класс LinkedList
• 31.9. Java – Класс ArrayList
• 31.10. Java – Класс HashSet
• 31.11. Java – Класс LinkedHashSet
• 31.12. Java – Класс TreeSet
• 31.13. Java – Класс HashMap
• 31.14. Java – Класс TreeMap
• 31.15. Java – Класс WeakHashMap
• 31.16. Java – Класс LinkedHashMap
• 31.17. Java – Класс IdentityHashMap
• 31.18. Java – Алгоритмы Collection
• 31.19. Java – Iterator и ListIterator
• 31.20. Java – Comparator
• 32. Java – Дженерики
• 33. Java – Сериализация
• 34. Java – Сеть
• 34.1. Java – Обработка URL
• 35. Java – Отправка Email
• 36. Java – Многопоточность
• 36.1. Java – Синхронизация потоков
• 36.2. Java – Межпоточная связь
• 36.3. Java – Взаимная блокировка потоков
• 36.4. Java – Управление потоками
• 37. Java – Основы работы с апплетами
• 38. Java – Javadoc

H Примитивные типы в Java в черновиках Tutorial

Примитивные типы в Java — важная, часто используемая часть языка, которая требует особого обращения. В этой публикации попробуем ответить на все вопросы связанные с примитивными типами, механизмом их работы, обработкой. Статья предназначена как для новичков, которые только стали на тернистый путь изучения Java (к ним отношусь и я), так и для людей, достаточно знакомым с языком, которые смогут освежить знания и, надеюсь, найдут что-то интересное для себя.

Примитивные типы

Примитивные типы немного нарушают объектную ориентированность языка Java, так так представляют одиночные (простые) значения. Эта особенность объясняется желанием обеспечить максимальную эффективность. Создавать объект простой переменной с помощью new недостаточно эффективно, так как new перемещает объект в кучу. Вместо этого создается «автоматическая» переменная, которая не является ссылкой на объект. Переменная хранит единственное значение и располагается в стеке. Стек — это область хранения данных, расположена в RAM. Процессор имеет прямой доступ до этой области через указатель на стек, поэтому стек — очень быстрый и эффективный способ хранения данных. По скорости стек уступает только регистрам (логично, так как регистры расположены внутри процессора).
Все размеры примитивных типов строго фиксированы и не зависят от машинной архитектуры. Это одна с причин улучшенной переносимости Java-программ.
В Java определено восемь примитивных типов, которые можно разбить на четыре группы:

Целые числа

Для целых чисел определены четыре примитивных типа: byte, short, int, long. Все эти типы представляют целочисленные значения со знаком: положительные или отрицательные. В Java нет положительных целочисленных значений без знака (unsigned). Как было сказано раньше, все размеры примитивных типов фиксированы:

Наименьшим целочисленным типом является byte. Переменные этого типа очень удобны для работы с потоками ввода-вывода и при манипулировании двоичными данными. Далее идет тип short, который применяется реже всех остальных типов. Наиболее часто употребляемым типом является int. Его постоянно используют в циклах, для индексации массивов. Может показаться, что использование типов byte и short в местах, где не требуется широкий диапазон значений, будет более эффективным чем использование int. Но это не так, потому что при вычислении выражений значения типа byte или short будут преобразованы в int (мы еще вернемся к этому вопросу). Когда длины типа int недостаточно для хранения значения, нужно использовать long. Его диапазон значений достаточно велик, что делает long удобным при работе с большими целыми числами.

Числа с плавающей точкой

Числа с плавающей точкой (или действительные числа) представлены типами float и double. Используются для хранения значений с точностью до определенного знака после десятичной точки.

Тип float определяет числовое значение с плавающей точкой одинарной точности. Этот тип используется, когда нужно числовое значение с дробной частью, но без особой точности. Тип double используется для хранений значений с плавающей точкой двойной точности. Обработка значений двойной точности выполняется быстрее, чем обработка значений одинарной точности. Поэтому большинство математических функций класса java.lang.Math возвращают значения типа double. Эффективнее всего использовать double, когда требуется сохранить точность многократно повторяющихся вычислений или манипулировать большими числами.

Символы

В спецификации примитивный тип char принадлежит к целочисленным типам (или integral types), но поскольку он играет немного другую роль, можно выделить для него собственную категорию. Его роль — представлять символы Unicode. Для хранения символов требуется 16 бит. Странно, ведь для представления символов основных языков (например, английского, французского, испанского) достаточно 8 бит. Но такая цена интернационализации. Unicode использует полный набор международных символов на всех известных языках мира.

Логические азначения

Примитивный тип boolean предназначен для хранения логических значений. Данный тип может принимать одно из двух возможных значений: true (истина) или false (ложь). Значения boolean возвращаются со всех логических операций (например, операции сравнения). Является обязательным при построении циклов, операторов (например, for, if).

Литералы

Значения примитивных типов данных в большинстве случаев инициализируются с помощью литералов. Рассмотрим их.

Целочисленные литералы

Наиболее часто используемые литералы. Любое целочисленное значение является числовым литералом (например, -10, 10 — десятичные значения). Можно использовать восьмеричные, шестнадцатеричные и двоичные литералы:

// десятичный литерал, числа [0, 9], не начинается с 0 int decimal = 10; // 10 // восьмеричный литерал начинается с 0, далее числа [0, 7] int octal = 010; // 8 // шестнадцатеричный литерал начинается с 0x или 0Х, далее числа [0, 9] и символы [a-f] int hexadecimal = 0x10; // 16 // двоичный литерал начинается с Оb или 0B, далее числа [0, 1] int binary = 0b10; // 2 

Все целочисленные литералы представляют значения int. Если значение литерала лежит в диапазоне byte, short или char, то его можно присвоить переменной этого типа без приведения типов. Для создания литерала типа long, необходимо явно указать компилятору, дополнив литерал буквой ‘l‘ или ‘L‘:

byte b1 = 127; byte b2 = 128; // ошибка short s1 = -32768; short s2 = -32769; // ошибка char c1 = 0; char c2 = -1; // ошибка long l1 = 10l; long l2 = 0x7fffffffffffffffL; // максимальное значение типа long 

Литералы с плавающей точкой

Существует две формы записи литеров с плавающей точкой: стандартная и экспоненциальная:

// стандартная форма double d1 = 0.; // эквивалентно .0 или 0.0; double d2 = 0.125; // экспоненциальная форма - используется символ 'e' или 'E' // после него степень числа 10, на которую следует умножить данное число double d3 = 125E+10; // если степень положительная, '+' можно упустить double d4 = 1.25e-10; 

Всех литералам с плавающей точкой по-умолчанию присваивается тип double. Поэтому чтобы создать литерал типа float, нужно после литерала указать букву ‘f‘ или ‘F‘. К литералам также можно добавлять букву ‘d‘ или ‘D‘, сообщая, что это литерал типа double, но зачем?

double d1 = 0.125; float f2 = 0.125f; 

Можно использовать шестнадцатеричные литералы с плавающей точкой, например:

// P - двоичный порядок, что обозначает степень числа 2, на которое следует умножить данное число double d = 0x10.P10d; // конечно, можно и без 'd' float f = 0x20.P10f; 

Для удобности чтения длинных литералов в 7 версии языка была добавлена возможность использовать символ ‘_’ внутри литерала:

// можно делать любые комбинации с использованием любого количества символов '_' int phone = 111__111__111; int bin = 0b1000_1000_1000; double dollars = 23_000.450__500; // не допускается использовать символ '_' в конце или начале литерала, также не можно разрывать '0x' и '0b' 

Символьные литералы

Символьные литералы заключаются в одинарные кавычки. Все отображаемые символы можно задавать таким способом. Если символ нельзя ввести непосредственно, используют управляющее последовательности начинающиеся с символа ‘\‘. Хотя все эти последовательности можно заменить соответствующим Unicode кодом. Также символьный литерал можно создать используя восьмеричную (‘\xxx’) и шестнадцатеричную форму (‘\uxxxx’).

char h = 'a'; // стандартная форма char a = '\001'; // восьмеричная форма char c = '\u0001'; // шестнадцатеричная форма 

Существуют также строковые литералы. Информацию о них можно получить тут.

Логические литералы

С логическими операторами все просто. Существует только два логических литерала:

boolean yes = true; // истина boolean no = false; // ложь 

Логические литералы можно присваивать только переменным типа boolean. Также важно понимать, что false не равен 0, а true не равен 1. Преобразовать переменную типа boolean в другие примитивные типы не выйдет.

Операции

Над целочисленными типами

• операторы сравнения (>, , >=, ) и равенства (==, !=)
• унарные операторы (+, —)
• мультипликативные (*, /, %) и аддитивные (+, —) операторы
• инкремент (++) и декремент (—) в префиксной и постфиксной формах
• знаковые (>>, <) и без знаковые (>>>) операторы сдвига
• побитовые операторы (~, &, ^, |)
• условный оператор (?: )
• оператор приведения типов

byte a = (byte)128; // - 128 byte b = (byte)42; // привидение возможно, но, в данном случаи, в нем нет необходимости int i1 = (int)1e20f; // 2147483647 int i2 = (int)Float.NaN; // 0 float f1 = (float)-1e100; // -Infinity float f2 = (float)1e-50; // 0.0 

int a = 100; float b = 50.0f; double c = 50.0; double result = a - b + c; // 100.0 // на самом деле: result = (double)((float)a - b) + c; 

// существует несколько способов создания Integer i1 = new Integer("10"); Integer i2 = new Integer(10); Integer i3 = Integer.valueOf(10); Integer i4 = Integer.valueOf("10", 10); // можно указать систему счисления, только для оберток целочисленных примитивных типов Character c1 = new Character('c'); // тут только один способ // получаем значения примитивных типов int i5 = i1.intValue(); char c2 = c1.charValue(); 

public static void main(String. s) < Integer i1 = 10; // автоупаковка - Integer.valueOf(10) int i2 = i1; // распаковка - i1.intValue() method(10); // автоупаковка в объект класса Integer - Integer.valueOf(10) ++i1; // распаковка - i1.intValue(), автоупаковка - Integer.valueOf(i1.intValue() + 1) >private static int method(Integer i) < return i; // распаковка объекта, принятого как параметр - i.intValue() >

Integer i1 = 128; i1.compareTo(5); // 1, то есть i.intValue() > Integer.valueOf(5) Integer.decode("0xabc"); // не работает с двоичными литералами Integer.parseInt("10", 3); // работает с любой системой счисления [2, 36] // метод преобразования i1.byteValue(); // (byte)i.intValue() // методы проверки Float f = 20.5f; Boolean badFloat = f.isInfinite() || f.isNaN(); // false, автоупаковка boolean // преобразование в строку f.toString();