L’autoboxing est la conversion automatique que le compilateur Java effectue entre les types primitifs et leurs classes d’encapsuleur d’objets correspondantes. Par exemple, convertir un int en un Integer, un double en un Double, etc. Si la conversion se déroule dans l’autre sens, cela s’appelle unboxing.

Voici l’exemple le plus simple d’auto-boxe :

Character ch = 'a';


Le reste des exemples de cette section utilise des génériques. Si vous ne connaissez pas encore la syntaxe des génériques, consultez la leçon Génériques (mise à jour).

Considérez le code suivant:

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2)
    li.add(i);


Bien que vous ajoutiez les valeurs int en tant que types primitifs, plutôt que des objets Integer, à li, le code se compile. Étant donné que li est une liste d’objets Integer et non une liste de valeurs int, vous pouvez vous demander pourquoi le compilateur Java n’émet pas d’erreur de compilation. Le compilateur ne génère pas d’erreur car il crée un objet Integer à partir de i et ajoute l’objet à li. Ainsi, le compilateur convertit le code précédent en code suivant au moment de l’exécution:

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2)
    li.add(Integer.valueOf(i));


La conversion d’une valeur primitive (un int, par exemple) en un objet de la classe wrapper correspondante (Integer) est appelée autoboxing. Le compilateur Java applique l’autoboxing lorsqu’une valeur primitive est:

Passé en tant que paramètre à une méthode qui attend un objet de la classe wrapper correspondante.
Affecté à une variable de la classe wrapper correspondante.
Considérez la méthode suivante:

public static int sumEven(List<Integer> li) {
    int sum = 0;
    for (Integer i: li)
        if (i % 2 == 0)
            sum += i;
        return sum;
}


Étant donné que les opérateurs reste (%) et unaire plus (+ =) ne s’appliquent pas aux objets Integer, vous pouvez vous demander pourquoi le compilateur Java compile la méthode sans émettre d’erreurs. Le compilateur ne génère pas d’erreur car il appelle la méthode intValue pour convertir un entier en entier au moment de l’exécution :

public static int sumEven(List<Integer> li) {
    int sum = 0;
    for (Integer i : li)
        if (i.intValue() % 2 == 0)
            sum += i.intValue();
        return sum;
}


La conversion d’un objet de type wrapper (Integer) en sa valeur primitive correspondante (int) s’appelle unboxing. Le compilateur Java applique le déballage lorsqu’un objet d’une classe wrapper est:

Passé en tant que paramètre à une méthode qui attend une valeur du type primitif correspondant.
Affecté à une variable du type primitif correspondant.
L’exemple Unboxing montre comment cela fonctionne:

import java.util.ArrayList;
import java.util.List;

public class Unboxing {

    public static void main(String[] args) {
        Integer i = new Integer(-8);

        // 1. Unboxing through method invocation
        int absVal = absoluteValue(i);
        System.out.println("absolute value of " + i + " = " + absVal);

        List<Double> ld = new ArrayList<>();
        ld.add(3.1416);    // Π is autoboxed through method invocation.

        // 2. Unboxing through assignment
        double pi = ld.get(0);
        System.out.println("pi = " + pi);
    }

    public static int absoluteValue(int i) {
        return (i < 0) ? -i : i;
    }
}


Le programme imprime les éléments suivants :

absolute value of -8 = 8
pi = 3.1416


L’autoboxing et le déballage permettent aux développeurs d’écrire un code plus propre, ce qui le rend plus facile à lire. Le tableau suivant répertorie les types primitifs et leurs classes wrapper correspondantes, qui sont utilisés par le compilateur Java pour l’autoboxing et le déballage :

Laisser un commentaire