Pourquoi utilisons-nous l'autoboxing et le unboxing en Java?
La sélection automatique est la conversion automatique effectuée par le compilateur Java entre les types primitifs et leur wrapper d'objet correspondant Des classes. Par exemple, convertir un entier en un entier, un double en un Double, et ainsi de suite. Si la conversion va dans l'autre sens, c'est appelé unboxing.
Alors, pourquoi en avons-nous besoin et pourquoi utilisons-nous l'autoboxing et le unboxing en Java?
Auto Boxing est utilisé pour convertir les types de données primitifs en objets de classe wrapper . La classe Wrapper fournit une large gamme de fonctions à exécuter sur les types primitifs. L'exemple le plus courant est:
int a = 56;
Integer i = a; // Auto Boxing
Il est nécessaire en raison de la facilité avec laquelle les programmeurs peuvent écrire directement du code et JVM se chargera du Boxing et du Unboxing.
La boxe automatique est également pratique lorsque nous travaillons avec les types Java.util.Collection. Lorsque nous voulons créer une collection de types primitifs, nous ne pouvons pas créer directement une collection d'un type primitif, nous pouvons créer une collection uniquement d'objets. Par exemple :
ArrayList<int> al = new ArrayList<int>(); // not supported
ArrayList<Integer> al = new ArrayList<Integer>(); // supported
al.add(45); //auto Boxing
Classes Wrapper
Chacun des 8 types primitifs de Java (octet, short, int, float, char, double, boolean, long) possède une classe Wrapper distincte qui leur est associée. Ces classes Wrapper ont des méthodes prédéfinies pour effectuer des opérations utiles sur des types de données primitifs.
Utilisation de Wrapper Classes
String s = "45";
int a = Integer.parseInt(s); // sets the value of a to 45.
Les classes Wrapper fournissent de nombreuses fonctions utiles. Consultez la documentation Java ici
Unboxing est l'opposé de la boxe automatique où nous reconvertissons l'objet de classe wrapper en son type primitif. Cette opération est effectuée automatiquement par la machine virtuelle Java afin que nous puissions utiliser les classes wrapper pour certaines opérations, puis les reconvertir en types primitifs car les primitives entraînent un traitement plus rapide. Par exemple :
Integer s = 45;
int a = s; auto UnBoxing;
Dans le cas de collections qui fonctionnent avec des objets, seul le déballage automatique est utilisé. Voici comment :
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(45);
int a = al.get(0); // returns the object of Integer . Automatically Unboxed .
À partir de JDK 5, Java a ajouté deux fonctions importantes: la sélection automatique et la boîte automatique. (AutoBoxing} _ est le processus pour lequel un type primitif est automatiquement encapsulé dans le wrapper équivalent chaque fois qu'un tel objet est nécessaire. Vous n'êtes pas obligé de construire explicitement un objet. Auto-Unboxing est le processus par lequel la valeur d'un objet encapsulé est automatiquement extraite d'un wrapper de type lorsque sa valeur est requise. Vous n'avez pas besoin d'appeler une méthode telle que intValue () ou doubleValue ().
L’ajout de la sélection automatique et de la décompression automatique facilite grandement le {simplifie l’écriture des algorithmes d’écriture}, _ _, éliminant ainsi l’appâtage manuel des valeurs. Il est également utile de éviter les erreurs. C'est également très important pour les génériques, qui n'agissent que sur des objets. Enfin, l'autoboxing facilite le travail avec le Collections Framework.
Les types primitifs (non-objets) ont leur justification en efficacité.
Les types primitifs int, boolean, double sont des données immédiates, alors que Objects sont des références. D'où champs (ou variables)
int i;
double x;
Object s;
aurait besoin de mémoire locale 4 + 8 + 8? où pour l'objet, seule la référence (adresse) à la mémoire est stockée.
En utilisant les wrappers Object Integer, Double et les autres, on introduirait une indirection, une référence à une instance Integer/Double dans la mémoire heap.
Pourquoi la boxe est-elle nécessaire?
C'est une question de portée relative. Dans un futur Java, il est prévu de pouvoir avoir un ArrayList<int>, levant des types primitifs.
Answer: Pour le moment, un ArrayList ne fonctionne que pour Object, réservant de la place pour une référence à un objet et gérant le garbage collection de la même manière. Par conséquent, types génériques sont des objets Object . Donc, si on voulait une ArrayList de valeurs à virgule flottante, il fallait envelopper un double dans un objet Double.
Ici, Java diffère du C++ traditionnel avec ses modèles: les classes C++ vector<string>, vector<int> créeraient deux produits de compilation. La conception Java visait à avoir une classe ArrayList.class, sans avoir besoin d'un nouveau produit compilé pour chaque type de paramètre.
Donc, sans boxing to Object, il faudrait compiler des classes pour chaque occurrence d'un type de paramètre. In concreto: chaque collection ou classe de conteneur aurait besoin d'une version pour Object, int, double, boolean. La version pour Object traiterait toutes les classes enfants.
En fait, Java SE nécessitait déjà une telle diversification pour IntBuffer, CharBuffer, DoubleBuffer, ... qui fonctionnent sur int, char, double. Il a été résolu de manière simpliste par génération ces sources à partir d'une source commune.
pourquoi avons-nous la (dé) boxe?
pour rendre le code où nous mélangeons les primitives et leurs alternatives orientées objet (OO) plus confortable/moins détaillé.
pourquoi avons-nous des primitives et leurs OO alternatives?
les types primitifs ne sont pas des classes (contrairement à C #), ils ne sont donc pas des sous-classes de Object et ne peuvent pas être remplacés.
nous avons des primitives telles que int pour des raisons de performances, et les alternatives Object telles que Integer pour les avantages de la programmation OO et un point mineur pour avoir un bon emplacement pour les constantes et méthodes d’utilité (Integer.MAX_VALUE et Integer.toString(int)).
Les avantages OO sont plus facilement visibles avec Generics (List<Integer>), mais ne se limitent pas à cela, par exemple:
Number getMeSome(boolean wantInt) {
if (wantInt) {
return Integer.MAX_VALUE;
} else {
return Long.MAX_VALUE;
}
}
Autoboxing: Conversion d'une valeur primitive en un objet de la classe d'encapsidation correspondante.
Unboxing: Conversion d'un objet d'un type wrapper en sa valeur primitive correspondante
// Java program to illustrate the concept
// of Autoboxing and Unboxing
import Java.io.*;
class GFG
{
public static void main (String[] args)
{
// creating an Integer Object
// with value 10.
Integer i = new Integer(10);
// unboxing the Object
int i1 = i;
System.out.println("Value of i: " + i);
System.out.println("Value of i1: " + i1);
//Autoboxing of char
Character gfg = 'a';
// Auto-unboxing of Character
char ch = gfg;
System.out.println("Value of ch: " + ch);
System.out.println("Value of gfg: " + gfg);
}
}
ArrayList ne prend pas en charge les types primitifs, mais uniquement la classe. mais nous devons utiliser des types primitifs, par exemple int, double, etc.
ArrayList<String> strArrayList = new ArrayList<String>(); // is accepted.
ArrayList<int> intArrayList = new ArrayList<int>(); // not accepted.
La classe Integer englobe une valeur du type primitif int dans un objet object.so, le code ci-dessous est accepté.
ArrayList<Integer> intArrayList = new ArrayList<Integer>(); // is accepted.
nous pouvons ajouter une valeur avec la méthode add (value) . Pour ajouter une valeur String, dites "Hello" dans le code strArrayList
strArrayList.add("Hello");
et ajouter une valeur int dire 54, nous pouvons écrire
intArrayList.add(54);
mais quand on écrit intArrayList.add (54); compilateur converti à la ligne suivante
intArrayList.add(Integer.valueOf(54));
Comme intArrayList.add (54) est facile et plus acceptable du côté utilisateur, le compilateur fait le travail difficile qui est `intArrayList.add(Integer.valueOf(54)); c'est autoBoxing.
De même, pour récupérer une valeur, nous tapons simplement IntArrayList.get (0) et le compilateur est converti en <code>intArrayList.get(0).intValue();, qui est autoUnboxing.
Parce qu'ils sont de types différents, et par commodité. Les performances sont probablement la raison d'avoir des types primitifs.
Certaines structures de données ne peuvent accepter que des objets, pas de types primitifs.
Exemple: la clé dans un HashMap.
Voir cette question pour en savoir plus: HashMap et int as key
Il existe d'autres bonnes raisons, telles qu'un champ "int" dans une base de données, qui peut également être NULL . Un int en Java ne peut pas être null; une référence entière peut. L'autoboxing et le unboxing permettent d'éviter d'écrire du code étranger dans les conversions.