Parlez de l'encapsulation automatique, du déballage et de l'analyse d'exemples dans les types de données Java

Objectif :

L'autoboxing et le unboxing ont été introduits à partir de Java 1.5 dans le but de convertir automatiquement les valeurs de type primitif convertir en l'objet correspondant , pour utiliser l'API de l'objet et les opérations de type référence. Le mécanisme automatique de boxing et de unboxing nous permet d'utiliser plus simplement et plus directement des types primitifs ou des types d'objets dans des affectations de variables ou des appels de méthodes en Java.

Définition :

Autoboxing signifie que Java convertit automatiquement les valeurs de type primitif en Objets correspondants, tels que la conversion de variables de int en objets Integer Ce processus est appelé boxing. 🎜>Les objets Integer sont convertis en valeurs de type int Ce processus est appelé unboxing. Étant donné que le boxing et le unboxing sont ici des conversions automatiques et non humaines, ils sont appelés boxing et unboxing automatiques. Les classes d'encapsulation correspondantes pour les types primitifs byte, short, char, int, long, float, double et boolean sont Octet, Court, Caractère, Entier, Long, Flottant, Double, Booléen .

Implémentation :

Lors de la boxe automatique, le compilateur appelle

valueOf pour convertir la valeur de type d'origine en objet, et automatiquement Lors du déballage, le compilateur convertit l'objet en valeur de type primitif en appelant des méthodes comme intValue(), doubleValue().

Heure d'occurrence :

Il existe une méthode qui accepte un paramètre de type objet Si nous passons une valeur de type primitif, alors Java

convertira automatiquement cette valeur de type primitif en objet correspondant.

Inconvénients de la boxe automatique :

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

Il y a un problème avec la boxe automatique, c'est-à-dire que l'opération de boxe automatique est effectuée en boucle, comme dans l'exemple suivant, des objets redondants seront créés, affectant les performances du programme.

Le code ci-dessus sum+=i peut être vu comme sum = sum + i,

mais

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

==

, + , -, *, / Cet opérateur ne s'applique pas à Integer objet , le premier sum effectue l'opération de déballage automatique, effectue l'opération d'addition numérique et enfin l'opération de boxe automatique se produit Convertir en objet Integer. Le processus est le suivant :

Puisque la

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

somme

que nous déclarons ici est de type Integer, dans la boucle ci-dessus Près de 5000 objets Integer inutiles seront créés dans une boucle aussi énorme, cela réduira les performances du programme et augmentera la charge de travail de. collecte des ordures. Par conséquent, vous devez y prêter attention et déclarer correctement les types de variables pour éviter les problèmes de performances causés par la boxe automatique.

Remarques

 : L'autoboxing et le unboxing peuvent rendre le code concis, mais nous devons faire attention lors de son utilisation, sinon certains problèmes surviendront.

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压力，拉低程序的性能。所以在写循环时一定要注意代码，避免引入不必要的自动装箱操作。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!