Aujourd’hui, en voici une concernant l’autoboxing/unboxing

L’AutoBoxing/UnBoxing

La fonctionnalité d’autoboxing / unboxing est une fonctionnalité qui fut très attendue par certains programmeurs. Mais l’introduction de cette fonctionnalité peut également vous jouer de mauvais tours si vous n’y prenez garde.

AutoBoxing
L’autoboxing est l’opération qui consiste à envelopper automatiquement une primitive dans sa classe enveloppe correspondante.

Au lieu d’être obligé d’écrire du code semblable à ceci:

Integer i = new Integer(1000);
Boolean b = new Boolean(true);
Character c = new Character('A');

vous pouvez maintenant écrire le code suivant:

Integer i = 1000;
Boolean b = true;
Character c = 'A';

Ce qui est, vous le reconnaitrer, tout de même plus pratique, pour encoder.

Mais attention: l’autoboxing introduit une petite subtilité.
Il faut bien comprendre quelle est le code qui est généré par l’autoboxing.

Lorsque vous écrivez le code source suivant

Integer i = 100;
Boolean b = true;
Character c = 'A';

Le bytecode généré ne correspond pas du tout au bytecode généré pour le code source suivant:

Integer i = new Integer(100);
Boolean b = new Boolean(true);
Character c = new Character('A');

Il correspond plutôt au bytecode généré pour le code source suivant:

Integer i = Integer.valueOf(100);
Boolean b = Boolean.valueOf(true);
Character c = Character.valueOf('A');

Et vous devez vraiment penser au fait que le compilateur travaille comme cela. Car cela peut avoir un énorme impact sur votre code.

Imaginer le code suivant:

public class ComparerDesBooleens {
    public static void main(String[] args) {
 
        //Bloc 1: Comparer des Boolean en utilisant les constructeurs
        {
            Boolean b = new Boolean(true);
            Boolean b2 = new Boolean(true);
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
        //Bloc 2: Comparer des Boolean en utilisant valueOf(boolean)
        {
            Boolean b = Boolean.valueOf(true);
            Boolean b2 = Boolean.valueOf(true);
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
 
        //Bloc 3: Comparer des Boolean en utilisant valueOf(String)
        {
            Boolean b = Boolean.valueOf("true");
            Boolean b2 = Boolean.valueOf("true");
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
         
        //Bloc 4: Comparer des Boolean en utilisant l'autoboxing
        {
            Boolean b = true;
            Boolean b2 = true;
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
    }
}

Le résultat à la console sera

b <> b2
b == b2
b == b2
b == b2

Pourquoi ?

Le fait d’appeler un constructeur, on crée toujours un nouvel Objet en mémoire. Et lorsqu’on compare les deux références, elles pointes vers deux objets bien distincts.

Par contre, les deux méthodes valueOf() ont été optimisées. En effet, la classe Boolean tient en cache deux objets: TRUE et FALSE. Et les méthodes valueOf() ont été optimisées pour toujours retourner une référence à l’un de ces deux objets.

Et l’autoboxing a été implémenté de telle façon qu’en réalité on appelle la méthode valueOf().

Nous venons de voir des exemples avec la classe Boolean qui possédait en effet une méthode valueOf(boolean). Mais les autres classes primitives, comme Integer ou Float, ne possedent pas de méthode valueOf(int) ou valueOf(float), me direz vous. En effet, cela était vrai jusqu’à présent. Mais depuis le JDK 5.0, ces classes possèdent ces méthodes. Et ce sont ces méthodes qui sont appelées lorsque vous utilisez l’autoboxing.

Si on reprend donc l’exemple précédent utilisé pour la classe Boolean et qu’on l’adapte pour la classe Integer. On aura le code suivant:

public class ComparerDesEntiers {
    public static void main(String[] args) {
         
        // On effectue 4 comparaisons avec des entiers construits 4 fois de manières différentes
 
        {
            Integer b = new Integer(1000);
            Integer b2 = new Integer(1000);
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
         
        {
            Integer b = Integer.valueOf(1000);
            Integer b2 = Integer.valueOf(1000);
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
         
        {
            Integer b = Integer.valueOf("1000");
            Integer b2 = Integer.valueOf("1000");
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
        {
            Integer b = 1000;
            Integer b2 = 1000;
             
            if (b==b2) {
                System.out.println("b == b2");
            }
            else {
                System.out.println("b <> b2");
            }
        }
    }
}

Qu’allons nous avoir à l’exécution ?
Le même résultat que pour la classe Boolean ?

b <> b2
b == b2
b == b2
b == b2

Non. Et la raison en est toute simple. C’est qu’on ne pouvait pas imaginer de mettre en cache un objet par nombre entier. Pour la classe Boolean, c’était facile, il n’y avait que 2 valeurs. Mais pour la classe Integer, il y a 2 exposants 32 valeurs possibles. Cela aurait fait 2 exposants 32 objets à mettre en cache. Cela n’était pas pensable. Et encore moins pour les Long, Float et/ou les Double.

Le résultat de l’exécution est donc:

b <> b2
b <> b2
b <> b2
b <> b2

Mais les développeurs de Sun ne se sont pas arrêtés là. Non, ils ont tout de même décider de mettre en cache, pour les classes enveloppes représentant des nombres entiers, les classes correspondantes aux nombre compris entre -128 et 127. Excepté pour la classe Character, qui ne peut contenir que des nombres entiers non signés, où la cache va de 0 à 127.

Si vous reprenez le code précédent concernant l’Integer, mais en utilisant la valeur 100 au lieu de 1000, le résultat de l’exécution sera donc:

b <> b2
b == b2
b <> b2
b == b2

Tiens. Pourquoi avons-nous b<>b2 comme résultat à la console pour

Integer b = Integer.valueOf("1000");
Integer b2 = Integer.valueOf("1000");
if (b==b2) {
  System.out.println("b == b2");
}
else {
  System.out.println("b <> b2");
}

Tout simplement, parce qu’il fallait qu’un programme écrit et compilé pour le JDK 1.4 donne les même résultats lorsqu’on qu’il est exécuté avec une JRE 1.4 qu’avec une JRE 5.0. Et la méthode valueOf(String value) existait déjà dans les versions précédentes du JDK 5.0 pour la classe Integer. Et retournait toujours un nouvel objet.

Aujourd’hui, en voici une concernant les primitives

Java ne possede pas que des objets. Il possède également des primitives.

En Java, il y a 9 primitives que l’on peut regrouper en 4 catégories (peut-être même 5):
1. nombres entiers: byte, short, char, int, long,
2. nombres décimaux: float, double
3. booléens: boolean
4. void: void
(5. caractères: char)

Comme vous le constater, la primitive char apparait dans deux catégories. En effet, char permet de stoquer un caractère au format UniCode. Mais il permet également de stoquer des nombres non signés entre 0 et 65535.

Les types de primitives numériques
Voici un tableau, avec à votre gauche la primitive, le nombre d’octets utilisés pour chacun, et les valeurs minimales et maximales.

byte     (8)  : [-128, 127]
short    (16) : [-32768, 32767]
char     (16) : [0, 65535]
int      (32) : [-2147483648, 2147483647]
long     (64) : [-9223372036854775808 , 9223372036854775807]
float    (32) : [1.4E-45, 3.4028235E38]
double   (64) : [4.9E-324, 1.7976931348623157E308]

le type de primitive boolean
Le type de primitive boolean n’accepte que deux valeurs: true et false.
la taille n’est pas imposée. Chaque implémentation de JVM est libre de choisir la taille occupée pour un boolean.

boolean boolean1 = true;
boolean boolean2 = false;

Le type de primitive void
Le type de primitive void est vraiment hors catégorie. En effet, on ne peut pas déclarer d’identifiant de ce type. Ce type de primitive n’accepte également aucune valeur.

void xxx; // ne passe pas à la compilation.

Mais, comme pour les autres types de primitives, il possede sa classe enveloppe correspondante.

Le type de primitive char
Comme vous l’avez vu dans le tableau ci-dessus, le type char est assez particulier puisqu’il appartient à la catégorie des nombres entiers, mais aussi à la catégories des caractères.

Le fragment de code suivant démontre que char se conduit (presque) comme les autres primitives numériques:

char nombre1= 65;
char nombre2 = 66;
// vous pouvez additionner deux nombres
char addition = (char) (nombre1 + nombre2);  
//N'affichera pas 65+66=131 mais A+B=AB
System.out.println(nombre1+"+"+nombre2+"="+nombre1+nombre2);  
//N'afichera pas 131=131 mais 131=AB
System.out.println(nombre1+nombre2+"="+nombre1+nombre2);

Mais, le type de primitive char permet également de stoquer et afficher des caractères:

char caractere1 = 'A';
char caractere2 = 'B';
System.out.println(caractere1); //affiche x
System.out.println(caractere2); //affiche y
System.out.println(caractere1+caracter2); //affiche 131 (résultat de l'addition de 65 (valeur interne de 'A') avec 66 (valeur interne de 'B'))

Particularité des types de primitives
Tous les types de primitives ont un « membre » qui est class.

Vous pouvez donc afficher la « classe » correspondante à ce type de primitives.

Voici un fragment de code,

System.out.println(int.class);
System.out.println(void.class.isPrimitive());

qui vous affichera

int
true

Aujourd’hui, en voici une concernant les mots réservés

Vous trouverez ci-dessous la liste des mots qui ne peuvent être utilisés comme identifiant, :

abstract
assert            introduit dans JDK 1.4
boolean           primitive
break
byte              primitive
case              
catch
char              primitive
class
const             Pas utilisé dans le langage. Mais fut réservé pour le cas où.
continue
default
do
double            primitive
else
enum              introduit dans JDK 5
extends
false             litteral
final
finally
float             primitive
for
goto              Pas utilisé dans le langage. Mais réservé pour éviter son usage.
if
implements
import
instanceof
int               primitive
interface
long              primitive
native
new
null              litteral
package
private
protected
public
return
short             primitive
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true              litteral
try
void              primitive
volatile
while

Tous ces mots sont réservés. Cela veut dire qu’il ne pourront jamais être utilisé comme identifiant, ni faire partie d’un nom de package.

Pas question d’écrire des choses semblables à ceci:

Enumeration enum = ...
public class volatile {...}
package com.developpez.brabant.certification.class;
package org.interface.project;
...

Mais rien ne vous empêche d’écrire des choses semblables à ceci:

Enumeration enums = ...
public class Volatile {...}
package com.developpez.brabant.certification.classes;
package org.interfaces.project;
...

Aujourd’hui, en voici une concernant les classes enveloppes

Les classes enveloppes

Nous avons fut dans la fiche précédente, qu’il y avait des types

Les classes enveloppes (Wrapper en anglais) sont les classes servant à envelopper ces fameux types de primitives. Ces classes enveloppes ne jouent pas que le rôle d’enveloppes. Elles jouent également le role de classes utilitaires car elle possèdent des méthodes permettant d’effectuer certaines opérations assez utiles.

Puisqu’il y a 9 primitives, vous trouverez également 9 classes enveloppes.
Voici un tableau avec à votre gauche la primitive et à droite la classe enveloppe correspondante.

byte     java.lang.Byte
short    java.lang.Short
char     java.lang.Character
int      java.lang.Integer
long     java.lang.Long
float    java.lang.Float
double   java.lang.Double

boolean  java.lang.Boolean

void     java.lang.Void

Il est intéressant de noter que les classes
Byte, Short, Integer, Long, Float et Double héritent toutes de la classe Number, mais pas la classe Character.
Ce qui tends bien à démontrer que le type de primitives char ne peut être entièrement rangé dans la catégorie des nombres, mais appartient également à la catégorie des caractères.

Classes enveloppes, mais également classes utilitaires

Comme nous le disions plus haut, les classes enveloppes font également office de classes utilitaires. Ainsi, toutes les classes enveloppes ont un membre statique TYPE qui retourne une instance de Class représentant le type de primitive correspondant.

Aussi

System.out.println(Integer.TYPE == int.class);

affiche

true

sur la console

les classes enveloppes pour les nombres (et également la classe Character) possèdent également des membres statiques MIN_VALUE et MAX_VALUE qui retourne les valeurs extremes qui peuvent être codées dans la taille qui lui est donnée, ainsi que SIZE qui retourne le taillé mémoire occupée par la primitive (le nombre de bits utilisés pour stoquer le nombre). Des classes comme Double, vous permet de vérifier qu’une valeur donnée est INFINI ou NaN (not a number).

Notez que SIZE fut introduit dans la version 5.0 de Java.

Voici un petit programme qui sert à afficher les valeurs extremes et la taille mémoire de la primitive pour le type correspondant. Attention que cela ne concerne que les classes enveloppes pour les nombres (ainsi que la classe Character).

public class Enveloppe{
    public static void main(String[] args) {
        //Les valeurs minimales
        Byte minByte = new Byte(Byte.MIN_VALUE);
        Short minShort = new Short(Short.MIN_VALUE);
        Character minCharacter = new Character(Character.MIN_VALUE);
        Integer minInteger = new Integer(Integer.MIN_VALUE);
        Long minLong = new Long(Long.MIN_VALUE);
        Float minFloat = new Float(Float.MIN_VALUE);
        Double minDouble = new Double(Double.MIN_VALUE);
         
        //Les valeurs maximales
        Byte maxByte = new Byte(Byte.MAX_VALUE);
        Short maxShort = new Short(Short.MAX_VALUE);
        Character maxCharacter = new Character(Character.MAX_VALUE);
        Integer maxInteger = new Integer(Integer.MAX_VALUE);
        Long maxLong = new Long(Long.MAX_VALUE);
        Float maxFloat = new Float(Float.MAX_VALUE);
        Double maxDouble = new Double(Double.MAX_VALUE);
         
        //Affiche taille, valeur minimale, et valeur maximale
        System.out.println(Byte.TYPE+" ("+Byte.SIZE+") : "+ minByte + " <-> "+maxByte);
        System.out.println(Short.TYPE+"("+Short.SIZE+") : "+ minShort + " <-> "+maxShort);
        System.out.println(Character.TYPE+"("+Character.SIZE+") : "+ (int) minCharacter + " <-> "+ (int) maxCharacter);
        System.out.println(Integer.TYPE+"("+Integer.SIZE+") : "+ minInteger + " <-> "+maxInteger);
        System.out.println(Long.TYPE+"("+Long.SIZE+") : "+ minLong + " <-> "+maxLong);
        System.out.println(Float.TYPE+"("+Float.SIZE+") : "+ minFloat + " <-> "+maxFloat);
        System.out.println(Double.TYPE+"("+Double.SIZE+") : "+ minDouble + " <-> "+maxDouble);
         
        System.out.println(minByte == Byte.MIN_VALUE);
        System.out.println(minShort == Short.MIN_VALUE);
        System.out.println(minCharacter == Character.MIN_VALUE);
        System.out.println(minInteger == Integer.MIN_VALUE);
        System.out.println(minLong == Long.MIN_VALUE);
        System.out.println(minFloat == Float.MIN_VALUE);
        System.out.println(minDouble == Double.MIN_VALUE);
        System.out.println(maxByte == Byte.MAX_VALUE);
        System.out.println(maxShort == Short.MAX_VALUE);
        System.out.println(maxCharacter == Character.MAX_VALUE);
        System.out.println(maxInteger == Integer.MAX_VALUE);
        System.out.println(maxLong == Long.MAX_VALUE);
        System.out.println(maxFloat == Float.MAX_VALUE);
        System.out.println(maxDouble == Double.MAX_VALUE);
         
        Double d = 1.0/0.0;
        Double d2 = -1.0/0.0;
        Double d3 = 0.0/0.0;
        System.out.println(d == Double.POSITIVE_INFINITY);
        System.out.println(d2 == Double.NEGATIVE_INFINITY);
        System.out.println(d3+" "+(d3 == Double.NaN));
        System.out.println(d3.isNaN());
    }
     
}

La classe Boolean
La classe Boolean possède également des membres statiques comme TRUE et FALSE, ainsi qu’une méthode valueOf() qui retourne toujours une référence aux mêmes objets référencés par TRUE et FALSE.

La classe Void
La classe Void est la classe la plus hors catégorie. En effet, c’est la seule classe enveloppe qui ne peut être instanciée et qui ne possède aucune méthode (exceptée celle héritée de la classe Object, bien évidemment) ni membre statique, excepté TYPE

La classe Character
C’est la classe contenant le plus de membres de toutes les classes enveloppes.
En effet, elle a des méthodes pour à peu près tout et n’importe quoi concernant les caractères.
Est ce que le caractère est une lettre? peut-il être utilisé dans un identifiant Java ? Est-ce une majuscule ? Quel est le caractère correspondant à sa minuscule ?
C’est la classe d’enveloppe qui a également connu le plus de modifications pour Java 5.

Mais aussi étrange que cela puisse paraître, la classe Character n’étend pas la classe Number.
Bizarre, vous avez dit bizarre. Comme c’est étrange.
Je n’ai aucune explication permettant d’expliquer pourquoi la classe Character n’hérite pas de la classe Number. Notez également que la classe Number ne possède pas de méthode charValue(), ce qui temd à prouver que char n’est pas vraiment à classifier dans les types de primitives numériques. Mais alors, pourquoi avoir fait le travail à moitier puisqu’on peut additionner des char entre eux aussi facilement ?

Si quelqu’un pouvait me donner la raison, j’en serais ravi. C’est juste par curiosité.

Mais examinons cela en détails, car il y a déjà plein de choses à dire.

En fait, il y plein de sous-entendu dans ce qu’on a écrit.

En effet, on peut dire que le code illustré ci-dessus est équivalent au code illustré ci-dessous.

Pour bien illustrer cela, vous pourriez écrire le code suivant: