Autoboxing et Unboxing en Java

Autoboxing est la conversion automatique du compilateur Java entre les types primitifs et leurs objets de classe wrapper correspondants, c'est-à-dire la conversion de int en Integer, double en Double, etc. Unboxing est la conversion automatique des objets de classe wrapper vers leurs primitives équivalentes, c'est-à-dire Entier à entier. La fonctionnalité a été introduite dans la version 1.5 de Java.

Comment fonctionnent l'Autoboxing et le Unboxing en Java ?

Le compilateur utilise la méthode valueOf() pour convertir les primitives en objets wrapper correspondants (c'est-à-dire l'autoboxing) en interne, et dans le cas inverse, il utilise intValue(), doubleValue(), etc., comme paradigmes pour le déballage.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Le mappage du type primitif et de la classe wrapper en Java est le suivant :

Primitive type	Wrapper class
boolean	Boolean
byte	Byte
char	Character
float	Float
int	Integer
long	Long
short	Short
double	Double

Exemples

Prenons une ArrayList d'entiers et utilisons le concept de déballage.

import java.util.ArrayList;
public class MyClass {
public static void main(String args[]) <em>{</em>
ArrayList<Integer> intlist = new ArrayList<Integer>();
//wrapper Integer objects being added here
intlist.add(1);
interest.add(2);
//auto-unboxing is happening here
int x = intlist.get(0);
System.out.println(x);
}
}

Par conséquent, dans l'exemple ci-dessus, en ajoutant de la valeur à x, nous voyons que x semble être primitif. En conséquence, le déballage s'effectue ici automatiquement pendant que la mission est terminée.

public class MyClass {
public static void main(String args[]) {
Integer sum =0;
for(int i=0;i<10;i++)
{
sum = sum + i;
}
System.out.println(sum);
}
}

• Ci-dessus, nous avons montré un deuxième exemple dans ce contexte, où un scénario typique a été présenté. Si vous êtes familier avec la création d'objets en Java, vous pouvez voir que « Somme entière = 0 » déclare un objet, et lorsque nous effectuons un calcul à l'intérieur de la boucle, nous pouvons voir que la valeur primitive « i » est ajoutée au enveloppe « somme ».
• Par conséquent, on peut constater que d'abord, la conversion du wrapper en primitif se produira, car l'opérateur « + » ne fonctionne que sur les primitives ; par conséquent, le déballage des objets aura lieu en premier. Ensuite, le calcul aura lieu, et après cela, l'autoboxing des objets se produira à nouveau. Ensuite, la valeur sera attribuée à la variable « somme ».
• Cela présente une surcharge inutile sur la JVM, car de nombreux objets Integer intermédiaires seront créés puis détruits (pour être ensuite récupérés), provoquant ainsi un ralentissement. En conséquence, de telles logiques doivent être traitées avec prudence.
• Voyons en quoi les conditions diffèrent des perceptions générales. Pour comprendre l'autoboxing et le unboxing, nous utiliserons du codage.

Considérez l'extrait placé ci-dessous ; quel sera le résultat de cela ?

public class Main
{
public static void main(String[] args) {
Integer m = 34123;
Integer x = 34123;
System.out.println(x==m);
}
}

• Si vous dites « vrai », alors vous êtes « faux », car le résultat est également « faux ». Puisque nous pouvons comparer la plage de nombres entiers de -128 à 127, les valeurs sortant de cette plage doivent être déballées.
• En conséquence, nous devons comparer intValue() des entiers ci-dessus. Pour l'instant, le compilateur fait cela en utilisant la propriété valueOf().
• Il est probable que si cela se situe dans la plage citée ci-dessus, alors le code ci-dessus tel quel donnera « vrai » — puisqu'il fera d'abord référence au pool de littéraux entiers à des fins de comparaison.

public class Main
{
public static void main(String[] args) {
Integer m = 100;
Integer x = 100;
System.out.println(x==m);
}
}

Ceci sera évalué à la « vraie » valeur, car 100 est présent dans le pool littéral.

Autoboxing et Unboxing en Java avec surcharge de méthodes

• Avant de marquer l'autoboxing et le unboxing avec la surcharge de méthodes, nous supposons que le lecteur comprend le concept de surcharge de méthodes. Nous ne donnerons que quelques informations, et pour plus d’informations, veuillez vous référer à la documentation d’Oracle à ce sujet.
• La surcharge de méthode est le processus de présentation de plusieurs variantes de n'importe quelle méthode de calcul en utilisant le même nom de méthode avec un nombre différent d'arguments d'entrée, différents types de données de variables portant les mêmes noms, etc.
• Prenons un exemple pour mieux comprendre. L'image de sortie est affichée ci-dessous.

public class Main
{
public static void main(String[] args) {
Overload obj =  new Overload();
int i =5;
obj.printval(5);
Integer m = i;
obj.printval(m);
}
}
class Overload
{
public void printval(int i)
{
System.out.println("printing the unboxed value "+ i);
}
public void printval(Integer i)
{
System.out.println("printing the autoboxed value "+ i);
}
}

Sortie :

Remarque : Vous pouvez exécuter le programme ci-dessus dans n'importe lequel des IDE pour obtenir le résultat ci-dessus.

• En conséquence, le comportement ci-dessus indique sans équivoque que la technique d'autoboxing est utile pour surcharger les concepts et doit être utilisée avec prudence lors du codage.

Avantages de l'Autoboxing et du Unboxing en Java

• Le compilateur entreprend automatiquement la conversion appropriée.
• Le développeur écrit moins de code, créant ainsi un code plus propre.
• Pas besoin d'expressions de conversion de type manuelle.

 Conclusion

Nous avons vu le cas d'utilisation de l'autoboxing et du unboxing et à quel point ce concept est implicite, ainsi que ses avantages et ses inconvénients. Il doit être utilisé avec prudence lors du codage ; sinon, cela peut ajouter une surcharge de conversion informatique inutile. Par conséquent, les conversions doivent être effectuées dans les primitives pour éviter une surcharge excessive de garbage collection et la création d'objets temporaires. Nous avons également vu le cas d'utilisation de l'autoboxing avec le concept de surcharge en Java. Vous pouvez vérifier quelques contraintes supplémentaires en même temps.

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!