Java wrapper classes (Wrapper)

Dans ce tutoriel, nous allons apprendre les classes enveloppeuses de Java (Wrapper) à l'aide d'exemples.

Les classes enveloppeuses en Java sont utilisées pour convertir les types primitifs (int, char, float, etc.) en leurs objets correspondants.

8Chaque type de base a une classe enveloppeuse correspondante.

Conversion des types de base en objets enveloppeurs

Nous pouvons également utiliser la méthode valueOf() pour convertir les types primitifs en leurs objets correspondants.

Exemple1：Type primaire de l'objet enveloppeur

class Main {
　　public static void main(String[] args) {
　　　　//Création de types primaires
　　　　int a =　5;
　　　　double b =　5.65;
　　　　//Conversion en objet enveloppeur
　　　　Integer aObj = Integer.valueOf(a);
　　　　Double bObj = Double.valueOf(b);
　　　　if(aObj instanceof Integer) {
　　　　　　System.out.println("Créer un objet Integer.");
　　　　}
　　　　if(bObj instanceof Double) {
　　　　　　System.out.println("Créer un objet Double.");
　　　　}
　　}
}

Résultat de la sortie

Créer un objet Integer.
Créer un objet Double.

Dans l'exemple précédent, nous avons utilisé la méthode valueOf() pour convertir les types primaires en objets.

Ici, nous utilisons l'opérateur instanceof pour vérifier si l'objet généré appartient au type Integer ou Double.

Mais, le compilateur Java peut directement convertir les types primaires en objets correspondants. Par exemple,

int a =　5;
//Conversion en objet
Integer aObj = a;
double b =　5.6;
//Conversion en objet
Double bObj = b;

This process is calledEmballage automatique.For more information, please visitJava automatic boxing and unboxing.

Note：Nous pouvons également utiliser le constructeur de la classe enveloppeuse (Wrapper) pour convertir les types primaires en objets enveloppeurs.Mais en Java 9Après cela, il n'est plus nécessaire d'utiliser le constructeur.

Conversion des objets enveloppeurs en types primaires

Pour convertir un objet en type primaire, nous pouvons utiliser la méthode de valeur correspondante de chaque classe enveloppeuse (intValue(), doubleValue()等).

Exemple2：Conversion des objets enveloppeurs en types primaires

class Main {
　　public static void main(String[] args) {
　　　　//Création d'objets de classes enveloppeuses
　　　　Integer aObj = Integer.valueOf(23);
　　　　Double bObj = Double.valueOf(5.55);
　　　　//Conversion en type primaire
　　　　int a = aObj.intValue();
　　　　double b = bObj.doubleValue();
　　　　System.out.println("La valeur de a: ")　+　a);
　　　　System.out.println("La valeur de b: ")　+　b);
　　}
}

Résultat de la sortie

La valeur de a:　23
La valeur de b:　5.55

Dans l'exemple précédent, nous avons utilisé les méthodes intValue() et doubleValue() pour convertir les objets Integer et Double en types primaires correspondants.

Mais, le compilateur Java peut automatiquement convertir les objets en types primaires correspondants. Par exemple,

Integer aObj = Integer.valueOf(2);
//Converted to int type
int a = aObj;
Double bObj = Double.valueOf(5.55);
//Converted to double type
double b = bObj;

This process is calledUnboxing.For more information, please visitJava automatic boxing and unboxing.

Advantages of wrapper classes

• In Java, sometimes we may need to use objects instead of primitive data types. For example, when using collections.

  //　Error
  ArrayList<int> list = new ArrayList<>();
  //Normal operation
  ArrayList<Integer> list = new ArrayList<>();

  In this case, the wrapper class can help us use primitive data types as objects.

• We can store null values in wrapper objects. For example,

  //An error will be generated
  int a = null;
  //　Normal operation
  Integer a = null;

NoteBasic types are more efficient than the corresponding objects. Therefore, it is always recommended to use primitive types when efficiency is needed.