Autoboxing et unboxing en Java

Dans cet article, nous examinerons une fonctionnalité de Java appelée autoboxing/unboxing . L'autoboxing et le unboxing sont une fonction de conversion des types primitifs en types d'objets et vice versa. L'ensemble du processus est effectué automatiquement par Java Runtime Environment (JRE). Mais vous devez être prudent lors de l'implémentation de cette fonction, car... Cela peut affecter les performances de votre programme.

Introduction

Dans les versions inférieures à JDK 1.5, il n'était pas facile de convertir des types de données primitifs tels que int, char, float, doubleen leurs classes wrapper Integer, Character, Float, Double. À partir du JDK 5, cette fonctionnalité, convertissant les types primitifs en objets équivalents, est implémentée automatiquement. Cette propriété est connue sous le nom d’ Autoboxing . Le processus inverse, respectivement, est Unboxing , c'est-à-dire le processus de conversion des objets en leurs types primitifs correspondants. Un exemple de code pour l'autoboxing et le unboxing est donné ci-dessous : Autoboxing

Integer integer = 9;

Déballage

int in = 0;
in = new Integer(9);

Quand l’emballage et le déballage automatiques sont-ils utilisés ? L'autoboxing est utilisé par le compilateur Java dans les conditions suivantes :

• Lorsqu'une valeur d'un type primitif est transmise à une méthode en tant que paramètre de méthode, celle-ci attend un objet de la classe wrapper correspondante.
• Lorsqu'une valeur d'un type primitif est affectée à une variable de la classe wrapper correspondante.

Prenons l'exemple suivant : Listing 1 : Code simple montrant l'autoboxing

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

Avant jdk 1.5, le code ci-dessus aurait provoqué une erreur de compilation car les opérateurs de reste % et unaire plus += ne pouvaient pas être appliqués à une classe wrapper. Mais dans jdk 1.5 et versions ultérieures, ce code se compile sans erreur, convertissant Integer en int. Le déballage est utilisé par le compilateur Java dans les conditions suivantes :

• Lorsqu'un objet est passé en paramètre à une méthode qui attend un type primitif correspondant.
• Lorsqu'un objet est affecté à une variable du type primitif correspondant.

Prenons l'exemple suivant : Listing 2 : Code simple montrant le déballage

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

public class UnboxingCheck {

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

// 1. Распаковка через вызов метода
int absVal = absoluteValue(in);
System.out.println("absolute value of " + in + " = " + absVal);

List<Double> doubleList = new ArrayList<Double>();

// Автоупаковка через вызов метода
doubleList.add(3.1416);

// 2. Распаковка через присвоение
double phi = doubleList.get(0);
System.out.println("phi = " + phi);
}

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

Le boxing et le déballage automatiques permettent au développeur d'écrire du code facile à lire et à comprendre. Le tableau suivant montre les types de données primitifs et leurs objets wrapper correspondants. Tableau 1 : Types primitifs et classes wrapper équivalentes avec opérateurs de comparaison L'autoboxing et le unboxing peuvent être utilisés avec des opérateurs de comparaison. L'extrait de code suivant illustre comment cela se produit : Listing 3 : exemple de code montrant le boxing et le déballage automatiques avec un opérateur de comparaison

public class BoxedComparator {
  public static void main(String[] args) {
      Integer in = new Integer(25);
      if (in < 35)
          System.out.println("Value of int = " + in);
  }
}

Emballage et déballage automatiques lors de la surcharge d'une méthode L'emballage et le déballage automatiques sont effectués lors de la surcharge d'une méthode en fonction des règles suivantes :

• L’expansion « va à l’encontre » de l’emballage dans une situation où il y a un choix entre l’expansion et l’emballage ; l’expansion est préférable.

Listing 4 : exemple de code montrant les avantages de la surcharge

public class WideBoxed {
  public class WideBoxed {
  static void methodWide(int i) {
       System.out.println("int");
   }

  static void methodWide( Integer i ) {
      System.out.println("Integer");
  }

  public static void main(String[] args) {
      short shVal = 25;
      methodWide(shVal);
  }
 }
}

Sortie du programme - typeint

• L'expansion bat le nombre variable d'arguments Dans une situation où il s'agit de choisir entre l'expansion et le nombre variable d'arguments, l'expansion est préférable.

Listing 5 : Exemple de code montrant les avantages de la surcharge

public class WideVarArgs {

    static void methodWideVar(int i1, int i2) {
      System.out.println("int int");
    }

    static void methodWideVar(Integer... i) {
       System.out.println("Integers");
    }

   public static void main( String[] args) {
       short shVal1 = 25;
      short shVal2 = 35;
     methodWideVar( shVal1, shVal2);
   }
  }

• L'empaquetage est préférable à un nombre variable d'arguments Dans une situation où il s'agit de choisir entre l'empaquetage et un nombre variable d'arguments, l'empaquetage est préférable.

Listing 6 : Exemple de code montrant les avantages de la surcharge

public class BoxVarargs {
     static void methodBoxVar(Integer in) {
         System.out.println("Integer");
     }

     static void methodBoxVar(Integer... i) {
         System.out.println("Integers");
     }
     public static void main(String[] args) {
         int intVal1 = 25;
         methodBoxVar(intVal1);
    }
}

Vous devez garder les éléments suivants à l’esprit lorsque vous utilisez Auto Packing : Comme nous le savons, chaque bonne fonctionnalité a un inconvénient. L’emballage automobile ne fait pas exception à cet égard. Quelques remarques importantes qu'un développeur doit garder à l'esprit lors de l'utilisation de cette fonctionnalité :

• Comparer des objets avec l' ==opérateur « » peut prêter à confusion, car il peut être appliqué à des types et objets primitifs. Lorsque cet opérateur est appliqué à des objets, il compare en réalité les références aux objets, et non aux objets eux-mêmes.

Listing 7 : exemple de code montrant la comparaison.

public class Comparator {
   public static void main(String[] args) {
     Integer istInt = new Integer(1);
       Integer secondInt = new Integer(1);

       if (istInt == secondInt) {
         System.out.println("both one are equal");

       } else {
          System.out.println("Both one are not equal");
      }
   }
}

• Mélanger des objets et des types primitifs avec les opérateurs d'égalité et relationnels. Si nous comparons un type primitif avec un objet, alors l'objet est déballé, ce qui peut être lancé NullPointerExceptionsi l'objet null.
• Mise en cache des objets. La méthode valueOf()crée un conteneur d'objets primitifs qu'elle met en cache. Étant donné que les valeurs mises en cache sont comprises entre -128 et 127 inclus, ces objets mis en cache peuvent se comporter différemment.
• Dégradation de la performance. Le boxing ou le déballage automatique dégrade les performances de l'application, car il crée un objet indésirable qui oblige le garbage collector à s'exécuter plus fréquemment.

Inconvénients de l'AutoBoxing Bien qu'AutoBoxing présente un certain nombre d'avantages, il présente les inconvénients suivants : Listing 8 : Exemple de code montrant le problème de performances.

public int sumEvenNumbers(List intList) {
          int sum = 0;
          for (Integer i : intList) {
              if (i % 2 == 0) {
                  sum += i;
              }
          }
         return sum;
   }

Dans cette section de code, sum +=i il sera étendu à sum = sum + i. En commençant par l' +opérateur « », la JVM commence le déballage car l' +opérateur « » ne peut pas être appliqué à un objet Integer. Et puis le résultat est automatiquement compressé. Avant JDK 1.5, les types de données intet Integer étaient différents. En cas de surcharge des méthodes, ces deux types ont été utilisés sans problème. Avec l’avènement de l’emballage/déballage automatique, cela est devenu plus difficile. Un exemple de ceci est la méthode surchargée remove()dans ArrayList. La classe ArrayLista deux méthodes de suppression - remove(index)et remove(object). Dans ce cas, la surcharge de la méthode ne se produira pas et la méthode correspondante sera appelée avec les paramètres appropriés.

Conclusion

L'autoboxing est un mécanisme permettant de convertir implicitement des types de données primitifs en classes wrapper (objets) correspondantes. Le compilateur utilise la méthode valueOf()pour convertir les types primitifs en objets, et les méthodes IntValue(), doubleValue()etc., pour obtenir les types primitifs de l'objet. Autoboxing convertit le type booléen booleanen booléen, byteen octet, charen caractère, floaten flottant, inten entier long, en long shortet en court. Le déballage s'effectue dans le sens inverse. Article original