Eingehende Analyse des automatischen Boxens und Unboxens von Java

Dies ist ein neuer Inhalt, der nach jdk1.5 eingeführt wurde. Da ich darauf bestehe, dass das Veröffentlichen der beste Speicher ist, habe ich beschlossen, meinen Speicher durch einen Blog zu ersetzen:
Die Java-Sprachspezifikation sagt: In vielen Fällen ist das Verpacken und Entpacken Wird vom Compiler selbst durchgeführt (in diesem Fall wird das Packen als Boxen bezeichnet, und das Entpacken wird als Unboxing bezeichnet).
Tatsächlich kann das automatische Boxen nach meinem eigenen Verständnis einfach als grundlegende Datentypen verstanden werden, die als Objekttypen gekapselt werden Beachten Sie die Objektorientierung von Java. Verwenden Sie beispielsweise int als Beispiel:

//声明一个Integer对象 
Integer num = 10; 
//以上的声明就是用到了自动的装箱：解析为 
Integer num = new Integer(10);以上就是一个很好的体现，因为10是属于基本数据类型的，原则上它是不能直接赋值给一个对象Integer的，但jdk1.5后你就可以进行这样的声明，这就是自动装箱的魅力 
自动将基本数据类型转化为对应的封装类型。成为一个对象以后就可以调用对象所声明的所有的方法 
自动拆箱：故名思议就是将对象重新转化为基本数据类型： 
//装箱 
Integer num = 10; 
//拆箱 
int num1 = num;自动拆箱有个很典型的用法就是在进行运算的时候：因为对象时不恩直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除 
Integer num = 10; 
//进行计算时隐含的有自动拆箱 
System.out.print(num--);哈哈 应该感觉很简单吧，下面我再来讲点稍微难点的， 
//在-128~127 之外的数 
Integer num1 = 297; Integer num2 = 297; 
System.out.println("num1==num2: "+(num1==num2)); 
// 在-128~127 之内的数 
Integer num3 = 97; Integer num4 = 97; 
System.out.println("num3==num4: "+(num3==num4)); 打印的结果是：num1==num2: false num3==num4: true

Es ist seltsam: Dies liegt an Javas automatischem Ein- und Auspacken von Integer und int. Das Design ist ein Muster: namens Flyweight-Muster ( Fliegengewicht)
Um die Wiederverwendung einfacher Zahlen zu erhöhen, definiert Java: Beim automatischen Boxen werden Werte von –128 bis 127 nach dem Boxen in ein Integer-Objekt gespeichert Speicher zur Wiederverwendung. Es gibt immer nur ein Objekt
und wenn es den Wert zwischen –128 und 127 überschreitet, wird das eingerahmte Integer-Objekt nicht wiederverwendet, d. h. es entspricht der Erstellung eines neuen Integer-Objekts jedes Mal boxed; Sie verstehen, dass das obige Phänomen durch die Verwendung von automatischem Boxen verursacht wird. Wenn Sie new wie die allgemeine Klasse verwenden, wird jedes Mal ein neues Objekt erstellt 🎜>Dieses automatische Boxen und Unboxing wird nicht nur in Basisdatentypen verwendet, sondern auch in der String-Klasse. Beispielsweise deklarieren wir häufig ein String-Objekt, wenn:

Autoboxing und Unboxing von Basisdaten (. Primitive Typen sind Funktionen, die seit J2SE 5.0 bereitgestellt werden. Obwohl es Ihnen das Packen grundlegender Datentypen erleichtert, werden auch die Details ausgeblendet. Es wird empfohlen, es nur zu verwenden, wenn Sie den Unterschied zwischen grundlegenden Datentypen und Objekten unterscheiden können.

String str = "sl"; 
//代替下面的声明方式 
String str = new String("sl");

Autoboxing und Unboxing

In Java ist fast alles, was verarbeitet werden soll, ein Objekt (Objekt), und der String (String) ist ebenfalls ein Objekt späteres Objekt. Grundlegende Datentypen sind jedoch keine Objekte, d. h. Variablen, die Sie mit int, double, boolean usw. definieren, und Literalkonstanten, in die Sie direkt schreiben.
Im vorherigen Abschnitt haben wir grob gesehen, wie praktisch die Bedienung von Objekten ist, und jeder, der Java schon länger verwendet, weiß, dass es manchmal notwendig ist, grundlegende Datentypen in Objekte umzuwandeln. Wenn Sie beispielsweise die put()-Methode eines Map-Objekts verwenden, müssen die Parameter, die übergeben werden müssen, Objekte und keine Basisdatentypen sein.
Sie müssen Wrapper-Typen (Wrapper-Typen) verwenden, um grundlegende Datentypen in Objekte zu verpacken. Im vorherigen Abschnitt wissen Sie bereits, dass Sie vor J2SE 5.0 die folgende Anweisung verwenden müssen, um int in ein Integer-Objekt zu verpacken: Integer integer = new Integer (10);
Die Auto-Boxing-Funktion wird nach J2SE 5.0 bereitgestellt. Sie können die folgende Anweisung direkt verwenden, um grundlegende Datentypen zu packen: Integer integer = 10;
Beim Kompilieren wird dies automatisch der Fall sein Schreiben Sie die Anweisung, um zu bestimmen, ob eine automatische Boxaktion ausgeführt werden soll. Im obigen Beispiel bezieht sich Integer auf eine Instanz der Integer-Klasse. Die gleiche Aktion kann auf grundlegende Datentypen wie Boolean, Byte, Short, Char, Long, Float, Double usw. und die entsprechenden Wrapper-Typen (Wrapper-Typen) Boolean, Byte, Short, Character, Long, Float oder angewendet werden Es wird jeweils das Doppelte verwendet. Lassen Sie uns direkt die Autoboxing-Funktion verwenden, um Beispiel 4.4 neu zu schreiben.

Beispiel 4.5 AutoBoxDemo.java

Das Programm scheint viel einfacher zu sein, da data1 und data2 zur Laufzeit Instanzen von Integer sind und Objektoperationen direkt ausführen können. Das Ergebnis ist wie folgt:

public class AutoBoxDemo { 
public static void main(String[] args) { 
Integer data1 = 10; 
Integer data2 = 20; 
// 转为double值再除以3 
System.out.println(data1.doubleValue() / 3); 
// 进行两个值的比较 
System.out.println(data1.compareTo(data2)); 
} 
}

3.3333333333333335

–1
Die Methode des automatischen Boxens kann auch wie folgt sein:

Sie können auch die allgemeinere java.lang.Number verwenden Klasse zum automatischen Packen. Beispiel:

int i = 10; 
Integer integer = i;

Number number = 3.14f;

3.14f wird automatisch zuerst als Float geboxt und dann der Nummer zugewiesen.
Ab J2SE 5.0 sind automatisches Boxen und automatisches Unboxen verfügbar, dh die grundlegenden Datenformularinformationen im Objekt werden automatisch aus dem Objekt entnommen. Beispielsweise ist es möglich, wie folgt zu schreiben:

Nachdem fooInteger auf eine Instanz verwiesen wurde, die automatisch als Integer geboxt wird, wird sie automatisch zu einer, wenn sie einer int-Typvariablen fooPrimitive zugewiesen wird int-Typ und dann fooPrimitive zugewiesen. Während des Betriebs kann auch ein automatisches Ein- und Auspacken durchgeführt werden. Beispiel:

Integer fooInteger = 10; 
int fooPrimitive = fooInteger;

Im obigen Beispiel werden 20 und 10 angezeigt. Der Compiler führt automatisch das Ein- und Auspacken durch, dh 10 wird zuerst eingepackt und dann zuerst ausgepackt, wenn i + 10 Box, Additionsoperation ausführen; i++-Zeile entpackt auch zuerst und führt dann eine Inkrementierungsoperation durch. Schauen wir uns ein anderes Beispiel an:

Integer i = 10; 
System.out.println(i + 10); 
System.out.println(i++);

Boolean boo = true; 
System.out.println(boo && false);

同样的boo原来是Boolean的实例，在进行AND运算时，会先将boo拆箱，再与false进行AND运算，结果会显示false。 
////////////////////////////////////////////////////////////////// 
装箱：从基本类型转换成Object类型，称之为装箱；***拆箱：从Object转换乘基本类型的操作，称之为拆箱。 这个操作在反射过程中用的比较的多。 
装箱：在堆中建立一个Object实例，把你指定的值复制成去；***拆箱：判别引用指向的堆中信息是否是要拆成的类型，是取出堆中值送给栈中变量，否则报异常 
/////////////////////////////////////////////////////////////////// 
装箱是值类型到object类型或到该值类型所实现的任何接口类型的隐士转换。 
将一个值类型装箱会分配一个对象实例并将该值复制到新的对象中。 

int i=123; 
object o=i;

这句话的结果是在堆栈上创建一个对象o,而该对象在堆上引用int类型的值。该值是赋值给变量i 
的值类型值的一个副本。 
下面是显示执行装箱转换 

int i=123; 
ojbect o=(object)i;

此例将整数变量i通过装箱转换为对象o。这样，存储在变量i中的值就从123改为456。此例显示对象保留了内容的原始副本。即123。 
取消装箱是从object类型到值类型或从接口类型到实现该接口的值类型的显示转换。取消装箱操作包括： 
检查对象实例，确保它是给定值类型的一个装箱值。 
将该值从实例复制到值类型变量中。 
例子： 

int i=123; 
object box=i; 
int j=(int)box;

更多java自动装箱拆箱深入剖析相关文章请关注PHP中文网！