Это новый контент, появившийся после jdk1.5. Поскольку я настаиваю на том, что публикация — лучшая память, я решил заменить свою память блогом:
В спецификации языка Java говорится: Во многих случаях упаковка и распаковка выполняются самим компилятором (в этом случае упаковка называется упаковкой, а распаковка называется распаковкой);
Фактически, по моему мнению, автоматический бокс можно просто понимать как инкапсуляцию базовых типов данных в типы объектов для соответствия объектной ориентации Java, например, используйте int в качестве примера:
Скопируйте код кода следующим образом:
//Объявляем целочисленный объект
Целое число = 10;
//Приведенный выше оператор использует автоматический бокс: анализируется как
Integer num = new Integer(10); Вышеприведенный пример является хорошим, поскольку 10 принадлежит базовому типу данных. В принципе, его нельзя напрямую присвоить объекту Integer, но после jdk1.5 вы можете сделать это. в этом прелесть автобокса, позволяющего автоматически преобразовывать базовые типы данных в соответствующие инкапсулированные типы. Став объектом, вы можете вызвать все методы, объявленные объектом, чтобы автоматически распаковать его: отсюда и название, оно означает повторное преобразование объекта в базовый тип данных:
//бокс
Целое число = 10;
//распаковка
int num1 = num; Очень типичное использование автоматической распаковки — при выполнении операций: поскольку объекты не используются напрямую, но должны быть преобразованы в базовые типы данных, прежде чем можно будет выполнить сложение, вычитание, умножение и деление.
Целое число = 10;
// Автоматическая распаковка неявна при выполнении вычислений
System.out.print(num--); Ха-ха, это должно быть очень просто. Теперь я расскажу о чем-то более сложном.
//Числа вне -128~127
Целое число1 = 297; Целое число2 = 297;
System.out.println("num1==num2: "+(num1==num2));
// Число в пределах -128~127
Целое число 3 = 97; Целое число 4 = 97;
System.out.println("num3==num4: "+(num3==num4)); Результат печати: num1==num2: false num3==num4: true
Это странно: это связано с дизайном Java автоматической упаковки и распаковки Integer и int. Это режим: называется режимом наилегчайшего веса (наилегчайший вес).
Чтобы увеличить повторное использование простых чисел, Java определяет: во время автоматического бокса для значений от 128 до 127, после того как они упакованы в целочисленные объекты, они будут храниться в памяти для повторного использования, и всегда будет только один объект И если оно превышает значение между 128 и 127, упакованный Inte. Объект ger не будет использоваться повторно, что эквивалентно созданию нового целочисленного объекта каждый раз, когда он упаковывается; поймите, что вышеуказанное явление вызвано использованием автоматического бокса, если вы не используете автоматический бокс, а следуете общим классам. , если вы используете new для создания экземпляра, новый объект будет создаваться каждый раз, когда используется new;
Эта автоматическая упаковка и распаковка используется не только в базовых типах данных, но и в классе String. Например, когда мы часто объявляем объект String:
Скопируйте код кода следующим образом:
Строка ул = "сл";
//Заменяем следующий метод объявления
Строка str = новая строка («sl»);
Автоупаковка и распаковка базовых типов данных (примитивных) — это функции, предоставляемые начиная с J2SE 5.0. Хотя он обеспечивает удобство упаковки базовых типов данных, он также скрывает детали. Его рекомендуется использовать только в том случае, если вы можете различить разницу между базовыми типами данных и объектами.
автобокс и распаковка
В Java почти все, что необходимо обработать, является объектом (Object). Например, используемый ранее Scanner является объектом, а String (String) также является объектом. Позже мы увидим больше объектов. Однако базовые типы данных не являются объектами, то есть переменными, которые вы определяете с помощью int, double, boolean и т. д., и литеральными константами, которые вы записываете непосредственно.
В предыдущем разделе мы примерно увидели удобство работы с объектами, и любой, кто какое-то время пользовался Java, знает, что иногда необходимо преобразовать базовые типы данных в объекты. Например, при использовании метода put() объекта Map параметры, которые необходимо передать, являются объектами, а не базовыми типами данных.
Вам необходимо использовать типы-оболочки (Wrapper Types) для переноса базовых типов данных в объекты. В предыдущем разделе вы уже знали, что до версии J2SE 5.0 вам нужно было использовать следующий оператор для переноса int в объект Integer: Integer Integer = new. Целое число(10) ;
Функция автоупаковки предоставляется после J2SE 5.0. Для упаковки базовых типов данных можно напрямую использовать следующий оператор: Целое число = 10;
При компиляции компилятор автоматически определит, следует ли выполнять автоматическую упаковку на основе написанных вами операторов. В приведенном выше примере целое число относится к экземпляру класса Integer. То же самое действие можно применить к базовым типам данных, таким как boolean, byte, short, char, long, float, double и т. д. Соответствующие типы оболочек (типы оберток) Boolean, Byte, Short, Символ, Long, Float или Double будут использоваться соответственно. Давайте напрямую воспользуемся функцией автобокса, чтобы переписать пример 4.4.
Пример 4.5 AutoBoxDemo.java
Скопируйте код кода следующим образом:
общественный класс AutoBoxDemo {
public static void main(String[] args) {
Целочисленные данные1 = 10;
Целочисленные данные2 = 20;
//Преобразуем в двойное значение и делим на 3
System.out.println(data1.doubleValue()/3);
//Сравниваем два значения
System.out.println(data1.compareTo(data2));
}
}
Программа кажется намного проще. data1 и data2 являются экземплярами Integer во время выполнения и могут напрямую выполнять операции с объектами. Результат следующий:
3.3333333333333335
1
Способ использования автоматического бокса также может быть следующим:
Скопируйте код кода следующим образом:
интервал я = 10;
Целое целое число = я;
Вы также можете использовать более общий класс java.lang.Number для автобокса. Например:
Номер номер = 3.14f;
3.14f будет автоматически помещен в коробку с плавающей запятой, а затем присвоен номер.
Начиная с J2SE 5.0, доступны автоматическая упаковка и автоматическая распаковка, то есть основная информация о форме данных в объекте автоматически извлекается из объекта. Например, можно написать следующее:
Скопируйте код кода следующим образом:
Целое число fooInteger = 10;
int fooPrimitive = fooInteger;
После ссылки на fooInteger на экземпляр, который автоматически упаковывается как Integer, если он назначен переменной fooPrimitive типа int, он автоматически изменится на тип int, а затем будет присвоен fooPrimitive. Во время работы также может выполняться автоматическая упаковка и распаковка. Например:
Скопируйте код кода следующим образом:
Целое число я = 10;
System.out.println(я + 10);
System.out.println(я++);
В приведенном выше примере будут отображены 20 и 10. Компилятор автоматически выполнит автоматическую упаковку и распаковку, то есть сначала будет упаковано 10, а затем сначала распаковано, когда i + 10, и будет выполнена операция сложения i++; Строка также будет сначала упакована в коробку, а затем будет выполнена операция увеличения. Давайте посмотрим на другой пример:
Скопируйте код кода следующим образом:
Логическое значение boo = true;
System.out.println(бу && ложь);
Тот же самый boo изначально является экземпляром Boolean. При выполнении операции AND сначала будет распакована boo, а затем объединена с помощью AND с false, и результат отобразит false.
/////////////////////////////////////////////////// /// //////////////////
Упаковка: преобразование базового типа в тип объекта называется упаковкой. ***Распаковка. Операция преобразования объекта в базовый тип называется распаковкой. Эта операция обычно используется в процессе отражения.
Упаковка: создайте экземпляр объекта в куче и скопируйте указанное вами значение. ***Распаковка: определите, относится ли информация в куче, на которую указывает ссылка, к типу, который нужно разделить, и возьмите значение из кучи и отправьте; его в переменную стека, иначе будет сообщено об исключении
/////////////////////////////////////////////////// /// ///////////////////
Упаковка — это закрытое преобразование типа значения в тип объекта или в любой тип интерфейса, который реализует тип значения.
При упаковке типа значения выделяется экземпляр объекта и копируется значение в новый объект.
Скопируйте код кода следующим образом:
интервал я = 123;
объект о = я;
Результатом этого предложения является создание объекта o в стеке, который ссылается на значение типа int в куче. Это значение присваивается переменной i
Копия значения типа значения.
Ниже приведен дисплей, выполняющий преобразование бокса.
Скопируйте код кода следующим образом:
интервал я = 123;
объект о = (объект) я;
В этом примере целочисленная переменная i преобразуется в объект o посредством упаковки. Таким образом, значение, хранящееся в переменной i, изменится со 123 на 456. Этот пример показывает, что объект сохраняет исходную копию содержимого. Это 123.
Распаковка — это явное преобразование типа объекта в тип значения или из типа интерфейса в тип значения, реализующий интерфейс. Операции распаковки включают в себя:
Проверяет экземпляр объекта, чтобы убедиться, что это упакованное значение заданного типа значения.
Копирует значение из экземпляра в переменную типа значения.
пример:
Скопируйте код кода следующим образом:
интервал я = 123;
поле объекта = я;
интервал j=(int)бокс;
