Classes enveloppe (Wrapper Classes) en Java - Number, Integer, Double ...

Maîtriser les huit types primitifs Java (int, double, boolean…). Comprendre la notion de classe, d'objet et de méthode. Avoir des notions sur les collections Java (ArrayList).

Objectifs

Comprendre le rôle des classes enveloppe et leur hiérarchie. Maîtriser les mécanismes d'autoboxing et d'unboxing. Utiliser les méthodes essentielles des classes enveloppe : xxxValue(), compareTo(), equals(), parseXxx(), toString() et valueOf().

1. Pourquoi des classes enveloppe ?

Définition — Classe enveloppe (Wrapper Class) Une classe enveloppe est une classe qui encapsule un type primitif dans un objet. Chaque type primitif Java possède une classe enveloppe correspondante dans le package java.lang.

Type primitif	Classe enveloppe	Valeur par défaut de l'objet
`byte`	`Byte`	`null`
`short`	`Short`	`null`
`int`	`Integer`	`null`
`long`	`Long`	`null`
`float`	`Float`	`null`
`double`	`Double`	`null`
`char`	`Character`	`null`
`boolean`	`Boolean`	`null`

1.1 Hiérarchie de la classe Number

Toutes les classes enveloppe numériques héritent de la classe abstraite java.lang.Number :

1.2 Quand utiliser les classes enveloppe ?

Situation	Raison
Collections Java (`ArrayList`, `HashMap`…)	Les collections ne stockent que des objets, pas des primitifs
Valeur nullable (`null`)	Un primitif ne peut pas être `null` — un objet si
Méthodes utilitaires de conversion	`Integer.parseInt()`, `Double.valueOf()`…
Génériques Java (`List<T>`)	Les paramètres de type doivent être des classes, pas des primitifs
Multithreading avec synchronisation	La synchronisation nécessite des objets

Exemple — Nécessité des classes enveloppe dans les collections

import java.util.ArrayList;

// ArrayList ne peut pas stocker des int directement
// ArrayList<int> liste = new ArrayList<>(); // Erreur !

// Il faut utiliser Integer (classe enveloppe)
ArrayList<Integer> liste = new ArrayList<>();
liste.add(10);  // autoboxing automatique : int → Integer
liste.add(20);
liste.add(30);

System.out.println("Taille : " + liste.size()); // 3
System.out.println("Premier : " + liste.get(0)); // 10

Sortie

Taille : 3
Premier : 10

2. Autoboxing et Unboxing

Définition — Autoboxing L'autoboxing est la conversion automatique effectuée par le compilateur Java d'un type primitif vers son objet enveloppe correspondant. Par exemple : int → Integer, double → Double.

Définition — Unboxing L'unboxing est le processus inverse : conversion automatique d'un objet enveloppe vers son type primitif correspondant. Par exemple : Integer → int, Double → double.

Exemple 1 — Autoboxing

// Instanciation classique (ancienne syntaxe, déconseillée depuis Java 9)
Integer i1 = new Integer(5);

// Autoboxing — le compilateur convertit automatiquement int → Integer
Integer i2 = 5;
Integer i3 = 42;

// Dans une expression
Integer somme = i2 + i3; // unboxing des deux → calcul → autoboxing du résultat
System.out.println("Somme : " + somme);

Sortie

Somme : 47

Exemple 2 — Unboxing

Integer objEntier = new Integer(5);

// Unboxing automatique : Integer → int
int primitif = objEntier;
System.out.println("Primitif : " + primitif);

// Unboxing dans une expression arithmétique
Integer a = 10;
Integer b = 3;
int resultat = a + b; // unboxing de a et b, puis addition
System.out.println("10 + 3 = " + resultat);

Sortie

Primitif : 5
10 + 3 = 13

Attention — NullPointerException lors de l'unboxing Si un objet enveloppe est null, l'unboxing automatique provoque une NullPointerException à l'exécution :

Integer val = null;
int x = val; // NullPointerException !

// Toujours vérifier null avant l'unboxing
if (val != null) {
    int x = val;
}

3. Méthodes communes — classe `Number`

3.1 Méthodes `xxxValue()` — conversion vers un primitif

xxxValue() Ces méthodes convertissent la valeur d'un objet Number vers un type primitif spécifique. La notation xxx représente le type cible : intValue(), doubleValue(), floatValue(), longValue(), byteValue(), shortValue().

Syntaxe — xxxValue() Java

byte    byteValue()
short   shortValue()
int     intValue()
long    longValue()
float   floatValue()
double  doubleValue()

Exemple 3 — Conversions avec xxxValue()

public class TestXxxValue {
    public static void main(String[] args) {
        Double d = 56.7689;

        System.out.println("intValue()    : " + d.intValue());    // troncature
        System.out.println("byteValue()   : " + d.byteValue());   // troncature
        System.out.println("shortValue()  : " + d.shortValue());  // troncature
        System.out.println("floatValue()  : " + d.floatValue());  // perte de précision
        System.out.println("doubleValue() : " + d.doubleValue()); // valeur exacte
        System.out.println("longValue()   : " + d.longValue());   // troncature
    }
}

Sortie

intValue()    : 56
byteValue()   : 56
shortValue()  : 56
floatValue()  : 56.7689
doubleValue() : 56.7689
longValue()   : 56

Perte de précision La conversion d'un Double vers int via intValue() tronque la partie décimale sans arrondi : 56.7689 devient 56, non 57. Pour arrondir, utilisez Math.round() avant la conversion.

3.2 Méthode `compareTo()` — comparaison d'objets Number

compareTo() Compare l'objet Number appelant à l'argument passé en paramètre. Les deux objets doivent être du même type. Retourne un entier négatif, zéro ou positif selon que l'objet est inférieur, égal ou supérieur à l'argument.

Valeur retournée	Signification	Exemple (`i = 10`)
`1` (valeur positive)	L'objet est supérieur à l'argument	`i.compareTo(7)` → `1`
`0`	L'objet est égal à l'argument	`i.compareTo(10)` → `0`
`-1` (valeur négative)	L'objet est inférieur à l'argument	`i.compareTo(11)` → `-1`

Exemple 4 — compareTo()

public class TestCompareTo {
    public static void main(String[] args) {
        Integer i = 10;

        System.out.println(i.compareTo(7));   //  1 : 10 > 7
        System.out.println(i.compareTo(11));  // -1 : 10 < 11
        System.out.println(i.compareTo(10));  //  0 : 10 == 10
    }
}

Sortie

1
-1
0

Utilisation de compareTo() dans le tri La méthode compareTo() est au cœur de l'interface Comparable et est utilisée par les algorithmes de tri de Java (Collections.sort(), Arrays.sort()) pour comparer des éléments.

3.3 Méthode `equals()` — égalité de valeur

equals() Détermine si deux objets Number ont la même valeur. Retourne true uniquement si l'argument est du même type et de la même valeur que l'objet appelant.

Exemple 5 — equals()

public class TestEquals {
    public static void main(String[] args) {
        Integer x = 5;
        Integer y = 10;
        Integer z = 5;
        Short   a = 5;

        System.out.println(x.equals(y)); // false : 5 != 10
        System.out.println(x.equals(z)); // true  : 5 == 5, même type
        System.out.println(x.equals(a)); // false : types différents (Integer vs Short)
    }
}

Sortie

false
true
false

Ne jamais comparer des Integer avec == L'opérateur == compare les références (adresses mémoire), pas les valeurs. Il peut donner des résultats inattendus avec les classes enveloppe :

Integer a = 127;
Integer b = 127;
System.out.println(a == b);     // true  (cache Java pour -128 à 127)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);     // false (hors du cache — objets différents)
System.out.println(c.equals(d)); // true  (valeurs égales — toujours utiliser equals)

Utilisez toujours equals() pour comparer des objets enveloppe.

4. Méthodes de conversion

4.1 `parseXxx()` — convertir une String en primitif

parseXxx() Méthode statique qui convertit une String en type primitif. Xxx est remplacé par le type cible : parseInt, parseDouble, parseLong, parseFloat… Un second paramètre optionnel (radix) précise la base numérique.

Méthode	Description	Exemple
`Integer.parseInt(String s)`	String → `int` (base 10)	`parseInt("42")` → `42`
`Integer.parseInt(String s, int radix)`	String → `int` (base spécifiée)	`parseInt("FF", 16)` → `255`
`Double.parseDouble(String s)`	String → `double`	`parseDouble("3.14")` → `3.14`
`Long.parseLong(String s)`	String → `long`	`parseLong("123456789")`
`Boolean.parseBoolean(String s)`	String → `boolean`	`parseBoolean("true")` → `true`

Exemple 6 — parseXxx()

public class TestParse {
    public static void main(String[] args) {
        int     x = Integer.parseInt("9");
        double  c = Double.parseDouble("5.75");
        int     b = Integer.parseInt("444", 16); // "444" en base 16 = 1092 en décimal
        long    l = Long.parseLong("8100000000");
        boolean v = Boolean.parseBoolean("true");

        System.out.println("parseInt(\"9\")          : " + x);
        System.out.println("parseDouble(\"5.75\")    : " + c);
        System.out.println("parseInt(\"444\", 16)    : " + b);
        System.out.println("parseLong(\"8100000000\"): " + l);
        System.out.println("parseBoolean(\"true\")   : " + v);
    }
}

Sortie

parseInt("9")          : 9
parseDouble("5.75")    : 5.75
parseInt("444", 16)    : 1092
parseLong("8100000000"): 8100000000
parseBoolean("true")   : true

NumberFormatException Si la chaîne passée à parseXxx() ne représente pas un nombre valide, une NumberFormatException est levée à l'exécution :

int x = Integer.parseInt("abc"); // NumberFormatException !
int y = Integer.parseInt("12.5"); // NumberFormatException (pas un entier) !

Entourez toujours un appel à parseXxx() avec un try-catch lorsque la chaîne provient d'une saisie utilisateur.

4.2 `toString()` — convertir un Number en String

toString() Convertit un objet Number ou un primitif en sa représentation String. La classe Integer offre également des variantes pour les conversions en binaire, hexadécimal et octal.

Exemple 7 — toString() et représentations

public class TestToString {
    public static void main(String[] args) {
        Integer x = 12;

        // Méthode d'instance — objet vers String
        System.out.println(x.toString());           // "12"

        // Méthode statique — int vers String
        System.out.println(Integer.toString(13));   // "13"

        // Conversions vers d'autres bases
        System.out.println(Integer.toBinaryString(35)); // "100011" (base 2)
        System.out.println(Integer.toHexString(30));    // "1e"     (base 16)
        System.out.println(Integer.toOctalString(12));  // "14"     (base 8)
    }
}

Sortie

4.3 `valueOf()` — créer un objet enveloppe

valueOf() Méthode statique qui retourne un objet enveloppe à partir d'un primitif ou d'une String. Contrairement à new Integer(5) (déconseillé depuis Java 9), Integer.valueOf(5) peut utiliser un cache interne pour les petites valeurs, ce qui est plus efficace.

Exemple 8 — valueOf()

public class TestValueOf {
    public static void main(String[] args) {
        Integer x = Integer.valueOf(9);           // int → Integer
        Double  c = Double.valueOf(5);            // int → Double (conversion implicite)
        Float   a = Float.valueOf("80");          // String → Float
        Integer b = Integer.valueOf("444", 16);  // String base 16 → Integer

        System.out.println(x); // 9
        System.out.println(c); // 5.0
        System.out.println(a); // 80.0
        System.out.println(b); // 1092
    }
}

Sortie

4.4 Comparaison — parseXxx() vs valueOf()

Méthode	Entrée	Sortie	Usage typique
`parseInt(String)`	`String`	`int` (primitif)	Calcul arithmétique après conversion
`valueOf(String)`	`String`	`Integer` (objet)	Stockage dans une collection
`valueOf(int)`	`int`	`Integer` (objet)	Créer un objet depuis un primitif (mieux que `new`)

5. Constantes utiles des classes enveloppe

Complément — Constantes MIN_VALUE et MAX_VALUE

Chaque classe enveloppe numérique expose les constantes MIN_VALUE et MAX_VALUE représentant les bornes du type primitif correspondant.

System.out.println("int min   : " + Integer.MIN_VALUE);   // -2 147 483 648
System.out.println("int max   : " + Integer.MAX_VALUE);   //  2 147 483 647
System.out.println("long max  : " + Long.MAX_VALUE);      //  9 223 372 036 854 775 807
System.out.println("double max: " + Double.MAX_VALUE);    //  1.7976931348623157E308
System.out.println("double NaN: " + Double.NaN);          // NaN (Not a Number)
System.out.println("double INF: " + Double.POSITIVE_INFINITY); // Infinity

Sortie

int min   : -2147483648
int max   : 2147483647
long max  : 9223372036854775807
double max: 1.7976931348623157E308
double NaN: NaN
double INF: Infinity

6. Exercice

Convertisseur de nombres en différentes bases

Niveau : Débutant

Écrire un programme Java qui lit une chaîne de caractères représentant un entier (en base 10), puis affiche ses représentations dans les quatre bases numériques classiques, ainsi que quelques informations comparatives.

Travail demandé

Utiliser Integer.parseInt() pour convertir la chaîne "255" en entier.
Afficher la valeur en binaire, octal et hexadécimal avec les méthodes toBinaryString(), toOctalString() et toHexString().
Convertir la chaîne hexadécimale "FF" en entier avec parseInt(s, 16) et vérifier qu'on obtient 255.
Utiliser compareTo() pour comparer 255 et 128.
Utiliser equals() pour vérifier si deux Integer ont la même valeur.

Sortie attendue

Sortie

=== Représentations de 255 ===
Décimal     : 255
Binaire     : 11111111
Octal       : 377
Hexadécimal : ff

=== Conversion retour ===
"FF" (base 16) → 255

=== Comparaisons ===
255.compareTo(128) : 1 (255 > 128)
255.compareTo(255) : 0 (égaux)
255.compareTo(300) : -1 (255 < 300)
Integer(255).equals(Integer(255)) : true
Integer(255).equals(Short(255))   : false

Solution détaillée

public class ConvertisseurBases {
    public static void main(String[] args) {

        // 1. Conversion String → int avec parseInt()
        int nombre = Integer.parseInt("255");

        // 2. Représentations dans différentes bases
        System.out.println("=== Représentations de " + nombre + " ===");
        System.out.println("Décimal     : " + nombre);
        System.out.println("Binaire     : " + Integer.toBinaryString(nombre));
        System.out.println("Octal       : " + Integer.toOctalString(nombre));
        System.out.println("Hexadécimal : " + Integer.toHexString(nombre));

        // 3. Conversion retour depuis hexadécimal
        int retour = Integer.parseInt("FF", 16);
        System.out.println("\n=== Conversion retour ===");
        System.out.println("\"FF\" (base 16) → " + retour);

        // 4. compareTo()
        Integer n1 = 255;
        System.out.println("\n=== Comparaisons ===");
        System.out.println("255.compareTo(128) : " + n1.compareTo(128)
                           + " (255 > 128)");
        System.out.println("255.compareTo(255) : " + n1.compareTo(255)
                           + " (égaux)");
        System.out.println("255.compareTo(300) : " + n1.compareTo(300)
                           + " (255 < 300)");

        // 5. equals()
        Integer n2 = 255;
        Short   s  = 255;
        System.out.println("Integer(255).equals(Integer(255)) : " + n1.equals(n2));
        System.out.println("Integer(255).equals(Short(255))   : " + n1.equals(s));
    }
}

Résultat :

Sortie

=== Représentations de 255 ===
Décimal     : 255
Binaire     : 11111111
Octal       : 377
Hexadécimal : ff

=== Conversion retour ===
"FF" (base 16) → 255

=== Comparaisons ===
255.compareTo(128) : 1 (255 > 128)
255.compareTo(255) : 0 (égaux)
255.compareTo(300) : -1 (255 < 300)
Integer(255).equals(Integer(255)) : true
Integer(255).equals(Short(255))   : false

Points clés :

parseInt("255") convertit la chaîne en int primitif — idéal pour les calculs.
toBinaryString(255) retourne "11111111" — 255 = 2⁸−1 (8 bits tous à 1).
parseInt("FF", 16) interprète "FF" comme un nombre hexadécimal (F=15, FF = 15×16+15 = 255).
equals() retourne false pour Integer(255) vs Short(255) : même valeur, mais types différents.
L'autoboxing permet d'écrire Integer n1 = 255 sans new Integer(255).

L'essentiel en bref

Les classes enveloppe (Integer, Double, Boolean…) permettent de traiter les types primitifs comme des objets, indispensable pour les collections et les génériques Java. L'autoboxing (primitif → objet) et l'unboxing (objet → primitif) sont effectués automatiquement par le compilateur depuis Java 5. Les méthodes essentielles sont : xxxValue() pour extraire un primitif depuis un objet, compareTo() pour comparer deux objets du même type, equals() pour tester l'égalité de valeur (à préférer à ==), parseXxx() pour convertir une String en primitif, toString() pour obtenir la représentation textuelle, et valueOf() pour créer un objet enveloppe de manière efficace. Attention au NullPointerException lors de l'unboxing d'un objet null, et au NumberFormatException lors d'un parseXxx() sur une chaîne invalide.

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Précédent Les variables en Java

Discussion (0)

Soyez le premier à laisser un commentaire !

Laisser un commentaire

Votre commentaire sera visible après modération.

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Classes enveloppe (Wrapper Classes) en Java - Number, Integer, Double ...