Sprechen Sie über automatische Kapselung, Unboxing und Beispielanalyse in Java-Datentypen

Zweck:

Autoboxing und Unboxing wurden ab Java 1.5 eingeführt, um primitive Typwerte automatisch zu konvertieren Konvertieren Sie in das entsprechende Objekt , , um die API des Objekts und Referenztypoperationen zu verwenden. Der automatische Boxing- und Unboxing-Mechanismus macht es für uns einfacher und direkter, primitive Typen oder Objekttypen in Variablenzuweisungen oder Methodenaufrufen in Java zu verwenden.

Definition:

Autoboxing bedeutet, dass Java primitive Typwerte automatisch in umwandelt Entsprechende Objekte, wie z. B. das Konvertieren von Variablen von int in Integer-Objekte. Andernfalls wird das Konvertieren von Integer-Objekte werden in Werte vom Typ int konvertiert. Dieser Vorgang wird als Unboxing bezeichnet. Da es sich beim Ein- und Auspacken hier um automatische und nichtmenschliche Konvertierungen handelt, werden sie als automatisches Ein- und Auspacken bezeichnet. Die entsprechenden Kapselungsklassen für primitive Typen byte, short, char, int, long, float, double und boolean sind Byte, Short, Character, Integer, Long, Float, Double, Boolean.

Implementierung:

Beim automatischen Boxen ruft der Compiler valueOf auf, um den ursprünglichen Typwert in ein Objekt umzuwandeln. und automatisch. Beim Unboxing konvertiert der Compiler das Objekt in einen primitiven Typwert, indem er Methoden wie intValue(), doubleValue() aufruft.

Auftrittszeit:

Es gibt eine Methode, die einen Parameter vom Objekttyp akzeptiert. Wenn wir einen primitiven Typwert übergeben, dann Java konvertiert diesen primitiven Typwert automatisch in das entsprechende Objekt.

List<Integer> list = new ArrayList<Integer>();
// 自动装箱
list.add(1);
list.add(2);
// 拆箱
int i = list.get(0);
int ii = list.get(1);

Nachteile des automatischen Boxens:

Es gibt ein Problem beim automatischen Boxen, das heißt, der automatische Boxvorgang wird in einer Schleife ausgeführt. Wie im folgenden Beispiel werden redundante Objekte erstellt, die sich auf die Leistung des Programms auswirken.

Integer sum = 0;
 for(int i=1000; i<5000; i++){
   sum+=i;
}

Der obige Code sum+=i kann als sum = sum + i,

aber ==, + , -, *, / Dieser Operator gilt nicht für Ganzzahl Objekt , erste Summe führt einen automatischen Unboxing-Vorgang durch, führt einen numerischen Additionsvorgang durch und schließlich erfolgt ein automatischer Boxing-Vorgang In ein Integer-Objekt konvertieren. Der -Prozess ist wie folgt:

int temp = sum.intValue() + i;
Integer sum = new Integer(temp);

Da die hier deklarierte

Summe vom Typ Ganzzahl ist, In der obigen Schleife werden fast 5000 nutzlose Integer-Objekte erstellt. In einer so großen Schleife wird die Leistung des Programms verringert und die Arbeitsbelastung erhöht Müllabfuhr. Daher müssen Sie darauf achten und Variablentypen korrekt deklarieren, um Leistungsprobleme durch automatisches Boxen zu vermeiden.

Hinweise:

Autoboxing und Unboxing können den Code prägnant machen, wir sollten jedoch bei der Verwendung darauf achten, da sonst einige Probleme auftreten.

1.比较

”==“可以用于原始值进行比较，也可以用于对象进行比较，当用于对象与对象之间比较时，比较的不是对象代表的值，而是检查两个对象是否是同一对象，即检查引用地址是否相同。这个比较过程中没有自动装箱发生。进行对象值比较不应该使用”==“，而应该使用对象对应的equals方法。

// 1
int i1=1;
int i2=1;
System.out.println(i2==i1);// true
// 2
Integer I1=1;
System.out.println(I1==i1);// true
Integer I2=1;
System.out.println(I1==I2);// true
// 3
Integer I3 = 128;// 触发自动封装
Integer I4 = 128;
System.out.println(I3==I4);// false
// 4
Integer I5= new Integer(1);// 不触发自动封装
Integer I6= new Integer(1);
System.out.println(I5==I6); // false

值得注意的是第2个小例子的第二个比较，这是一种极端情况。I1和I2的初始化都发生了自动装箱操作。但是处于节省内存的考虑，JVM会缓存-128到127的Integer对象。因为I1和I2实际上是同一个对象。所以使用”==“比较返回true,而第三个小例子使用‘==’返回false。

注：自动封装的函数

public static Integer valueOf(int i) {
 return i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
 }
private static final Integer[] SMALL_VALUES = new Integer[256];

2.容易混乱的对象和原始数据值

另一个需要避免的问题就是混乱使用对象和原始数据值，一个具体的例子就是当我们在一个原始数据值与一个对象进行比较或赋值时，如果这个对象没有进行初始化或者为Null，在自动拆箱过程中obj.xxxValue，会抛出NullPointerException,如下面的代码

private static Integer count;
if(count>=0){
System.out.println(11111111111L);
}

3.缓存的对象

在Java中，会对-128到127的Integer对象进行缓存，当创建新的Integer对象时，如果符合这个这个范围，并且已有存在的相同值的对象，则返回这个对象，否则创建新的Integer对象。

4.生成无用对象

因为自动装箱会隐式地创建对象，像前面提到的那样，如果在一个循环体中，会创建无用的中间对象，这样会增加GC压力，拉低程序的性能。所以在写循环时一定要注意代码，避免引入不必要的自动装箱操作。

Das obige ist der detaillierte Inhalt vonSprechen Sie über automatische Kapselung, Unboxing und Beispielanalyse in Java-Datentypen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!