Classe wrapper Java
Classe wrapper Java
Dans ce didacticiel, nous allons découvrir la classe Java Wrapper à l'aide d'exemples.
Les classes wrapper en Java sont utilisées pour convertir les types primitifs (int , char , float , etc) dans les objets correspondants.
Chacun des 8 types primitifs a des classes wrapper correspondantes.
| Type primitif | Classe Wrapper |
|---|---|
byte | Byte |
boolean | Boolean |
char | Character |
double | Double |
float | Float |
int | Integer |
long | Long |
short | Short |
Convertir le type primitif en objets wrapper
On peut aussi utiliser le valueOf() méthode pour convertir les types primitifs en objets correspondants.
Exemple 1 :Types primitifs pour les objets wrapper
class Main {
public static void main(String[] args) {
// create primitive types
int a = 5;
double b = 5.65;
//converts into wrapper objects
Integer aObj = Integer.valueOf(a);
Double bObj = Double.valueOf(b);
if(aObj instanceof Integer) {
System.out.println("An object of Integer is created.");
}
if(bObj instanceof Double) {
System.out.println("An object of Double is created.");
}
}
}
Sortie
An object of Integer is created. An object of Double is created.
Dans l'exemple ci-dessus, nous avons utilisé le valueOf() méthode pour convertir les types primitifs en objets.
Ici, nous avons utilisé le instanceof opérateur pour vérifier si les objets générés sont de Integer ou Double taper ou non.
Cependant, le compilateur Java peut convertir directement les types primitifs en objets correspondants. Par exemple,
int a = 5;
// converts into object
Integer aObj = a;
double b = 5.6;
// converts into object
Double bObj = b;
Ce processus est connu sous le nom de auto-boxing . Pour en savoir plus, consultez Java autoboxing and unboxing.
Remarque :Nous pouvons également convertir des types primitifs en objets wrapper en utilisant Wrapper constructeurs de classes. Mais l'utilisation des constructeurs est abandonnée après Java 9.
Envelopper des objets dans des types primitifs
Pour convertir des objets dans les types primitifs, nous pouvons utiliser les méthodes de valeur correspondantes (intValue() , doubleValue() , etc) présents dans chaque classe wrapper.
Exemple 2 :encapsuler des objets dans des types primitifs
class Main {
public static void main(String[] args) {
// creates objects of wrapper class
Integer aObj = Integer.valueOf(23);
Double bObj = Double.valueOf(5.55);
// converts into primitive types
int a = aObj.intValue();
double b = bObj.doubleValue();
System.out.println("The value of a: " + a);
System.out.println("The value of b: " + b);
}
}
Sortie
The value of a: 23 The value of b: 5.55
Dans l'exemple ci-dessus, nous avons utilisé le intValue() et doubleValue() méthode pour convertir le Integer et Double objets en types primitifs correspondants.
Cependant, le compilateur Java peut convertir automatiquement les objets en types primitifs correspondants. Par exemple,
Integer aObj = Integer.valueOf(2);
// converts into int type
int a = aObj;
Double bObj = Double.valueOf(5.55);
// converts into double type
double b = bObj;
Ce processus est connu sous le nom de déballage. . Pour en savoir plus, consultez Java autoboxing and unboxing.
Avantages des classes Wrapper
- En Java, nous pouvons parfois avoir besoin d'utiliser des objets au lieu de types de données primitifs. Par exemple, lorsque vous travaillez avec des collections.
Dans de tels cas, les classes wrapper nous aident à utiliser les types de données primitifs comme objets.// error ArrayList<int> list = new ArrayList<>(); // runs perfectly ArrayList<Integer> list = new ArrayList<>(); - Nous pouvons stocker la valeur nulle dans des objets wrapper. Par exemple,
// generates an error int a = null; // runs perfectly Integer a = null;
Remarque :Les types primitifs sont plus efficaces que les objets correspondants. Par conséquent, lorsque l'efficacité est une exigence, il est toujours recommandé d'utiliser des types primitifs.
Java