Autoboxing et Unboxing en Java

1. Autoboxing en Java
2. Déballage en Java

L’autoboxing convertit les types de données primitifs en leur type wrapper équivalent, et le déballage est la conversion des types wrapper en types de données primitifs. Cette fonctionnalité est intégrée à Java.

Ce didacticiel décrit et illustre l’utilisation de l’auto-boxing et de l’unboxing en Java.

Autoboxing en Java

Comme mentionné ci-dessus, l’auto-boxing convertit les types de données primitifs dans la même classe de type wrapper qu’un objet. Par exemple, long à Long ou int à Integer.

La liste de ces types de données primitifs et leur classe de type wrapper correspondante est ci-dessous.

Il existe trois cas où nous pouvons utiliser l’auto-boxing en Java :

1. Nous devons passer un type de données primitif comme paramètre dans n’importe quelle méthode. Cette méthode nécessite un objet de classe wrapper correspondant.
2. Lors de l’affectation d’un type de données primitif à une variable avec une classe wrapper correspondante.
3. Tout en travaillant avec des classes de framework de collection, le compilateur doit effectuer un autoboxing en Java.

Il y a trois cas. Essayons de créer un exemple pour chaque cas. Voir l’exemple pour le premier cas :

package Delfstack;

public class Autoboxing_Test {
  public static void Number(Integer x) {
    System.out.println(x);
  }
  public static void main(String[] args) {
    // Compiler performs Autoboxing here. it converts primitive type to wrapper type Integer object.
    int x = 10;
    Number(x);
  }
}

Nous avons passé un type primitif int en tant que paramètre dans une méthode qui nécessite la classe wrapper Integer ; le compilateur effectuera l’autoboxing ici. Voir la sortie :

10

Voir l’exemple pour le second cas :

package Delfstack;

public class Autoboxing_Test {
  public static void main(String[] args) {
    // Assigning primitive long value to Wrapper Long variable x. Compiler performs autoboxing
    Long x = 430L;
    // Assigning primitive char value to Wrapper Character variable y. Compiler performs autoboxing
    Character y = 'a';
    System.out.println(x);
    System.out.println(y);
  }
}

Nous avons attribué des valeurs de type de données primitives à la variable de type wrapper et le compilateur a effectué l’autoboxing. Voir la sortie :

430
a

Voir l’exemple pour le troisième cas :

package Delfstack;

import java.util.ArrayList;

public class Autoboxing_Test {
  public static void main(String[] args) {
    ArrayList<Long> Long_List = new ArrayList<Long>();
    // while working with collections framework the compiler performs autoboxing
    Long_List.add(220L);
    Long_List.add(330L);
    System.out.println(Long_List);
  }
}

Tout en travaillant avec des classes de framework de collection, le compilateur doit effectuer une autoboxing en Java comme dans le code ci-dessus ; nous ajoutons des éléments de type primitif long à la liste Long de type wrapper. Voir la sortie :

[220, 330]

Déballage en Java

L’unboxing en Java convertit un objet d’une classe wrapper dans le même type de données primitif ; c’est l’opération inverse de l’autoboxing. Par exemple, en convertissant Integer en int ou Long en long, le tableau précédent peut également être utilisé pour la boxe et vice versa.

Le unboxing peut également être appliqué dans trois cas :

1. Lors du passage d’un objet d’une classe wrapper à une méthode qui nécessite une valeur de type primitif.
2. Lorsque l’objet de la classe wrapper est affecté à la variable primitive correspondante.
3. Tout en travaillant avec des cadres de collecte.

Essayons un exemple pour chaque cas en Java. Voir l’exemple pour le premier cas :

package Delfstack;

public class Unboxing_Test {
  public static void Number(int x) {
    System.out.println(x);
  }
  public static void main(String[] args) {
    Integer x = new Integer(340);
    // We passed Integer wrapper class object, the compiler will convert it to int because method
    // requires int
    Number(x);
  }
}

Le compilateur effectuera un déballage tout en passant un objet d’une classe wrapper à une méthode qui nécessite une valeur avec un type primitif. Voir la sortie :

340

L’exemple pour le second cas :

package Delfstack;

public class Unboxing_Test {
  public static void main(String[] args) {
    Long x = new Long(340L);
    Integer y = new Integer(450);
    // Performing unboxing here. assigning Long object to primitive long type similarly Integer to
    // int
    long a = x;
    int b = y;

    System.out.println(a);
    System.out.println(b);
  }
}

Le compilateur effectuera un déballage lorsque l’objet de la classe wrapper est affecté à la variable primitive correspondante. Voir la sortie :

340
450

L’exemple pour le troisième cas :

package Delfstack;

import java.util.ArrayList;

public class Unboxing_Test {
  public static void main(String[] args) {
    ArrayList<Long> Long_List = new ArrayList<Long>();
    Long_List.add(230L);
    Long_List.add(340L);
    Long_List.add(450L);
    // The get method returns an Long object and we assigned it to the long primitive type
    long x = (long) Long_List.get(0);
    long y = (long) Long_List.get(1);
    long z = (long) Long_List.get(2);

    System.out.println(x);
    System.out.println(y);
    System.out.println(z);
  }
}

Tout en travaillant avec des frameworks de collection comme ArrayList, le compilateur effectue un déballage lorsque nous essayons d’affecter des éléments de liste ArrayList à des variables de type primitif. Voir la sortie :

230
340
450