Comprendre les classes Wrapper Java : types, conversions et avantages

Les classes Wrapper en Java

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

Les classes Wrapper Java convertissent les types primitifs (int, char, float, etc.) en leurs représentations objet correspondantes.

Chacun des huit types primitifs possède une classe wrapper dédiée.

Type primitif	Classe Wrapper
byte	Byte
boolean	Boolean
char	Character
double	Double
float	Float
int	Integer
long	Long
short	Short

---

Convertir un type primitif en objet Wrapper

Utilisez la méthode valueOf() pour transformer explicitement un primitif en son objet wrapper.

Exemple 1 : Types primitifs vers objets Wrapper

class Main {
    public static void main(String[] args) {
        int a = 5;
        double b = 5.65;
        Integer aObj = Integer.valueOf(a);
        Double bObj = Double.valueOf(b);
        if (aObj instanceof Integer) {
            System.out.println("Un objet Integer est créé.");
        }
        if (bObj instanceof Double) {
            System.out.println("Un objet Double est créé.");
        }
    }
}

Sortie

Un objet Integer est créé. Un objet Double est créé.

Le code ci-dessus démontre la conversion explicite via valueOf(). Java prend également en charge l'auto-boxing, où les primitifs sont implicitement enveloppés :

int a = 5;
Integer aObj = a;
double b = 5.6;
Double bObj = b;

Pour en savoir plus sur l'auto-boxing et unboxing, consultez notre guide dédié.

Note : Avant Java 9, les objets wrapper pouvaient également être créés via des constructeurs (ex: new Integer(a)), mais cette approche est dépréciée.

---

Convertir des objets Wrapper en types primitifs

Pour récupérer le primitif sous-jacent, appelez la méthode …Value() correspondante sur l'objet wrapper.

Exemple 2 : Objets Wrapper vers types primitifs

class Main {
    public static void main(String[] args) {
        Integer aObj = Integer.valueOf(23);
        Double bObj = Double.valueOf(5.55);
        int a = aObj.intValue();
        double b = bObj.doubleValue();
        System.out.println("La valeur de a : " + a);
        System.out.println("La valeur de b : " + b);
    }
}

Sortie

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

Java effectue également l'unboxing automatiquement :

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

Consultez l'article sur l'auto-boxing et unboxing pour plus de détails.

---

Avantages des classes Wrapper

• Lorsque les collections nécessitent des objets, les classes wrapper comblent le fossé entre les primitifs et les objets.

  // erreur
  ArrayList<int> list = new ArrayList<>();
  // fonctionne parfaitement
  ArrayList<Integer> list = new ArrayList<>();

• Les objets wrapper peuvent contenir null, permettant des références nullables.

  // génère une erreur
  int a = null;
  // fonctionne parfaitement
  Integer a = null;

Note : Les types primitifs sont généralement plus efficaces que leurs homologues objets ; utilisez les primitifs quand la performance est critique.