juillet
2005
L’UnBoxing
L’Unboxing est l’opération inverse de l’autoboxing. On prend la valeur de la classe enveloppe pour en faire une primitive.
Exemple de code où on fait de l’UnBoxing:
{
Integer i = new Integer(100); //Création d'une classe enveloppant la valeur 100
int j = i.intValue(); //Ce qu'on aurait du faire avec une version antérieure au JDK 5.0
int j = i; //Unboxing de Integer en int.
}
En fait l’instruction
int j = i;
est traduite par
int j = i.intValue();
lors de la compilation.
L’UnBoxing permet également de faire des opérations mathématiques.
Ainsi, nous pouvons avoir
{
Integer i = 70;
Integer j = 10;
int resultatMultiplication = i * j;
int resultatAddition = i + j;
int resultatSoustraction = i - j;
int resultatDivision = i / j;
}
Ou même faire une boucle for avec une classe enveloppe.
{
for (Integer i = new Integer(0); i<150; i++) {
System.out.println(i);
}
}
Nous pouvons bien évidemment mélanger les deux en même temps.
Ainsi, en reprenant nos deux exemples précédents, nous pouvons avoir quelque chose du style:
{
//AutoBoxing
Integer i = 70;
Integer j = 10;
//Unboxing pour le calcul, puis autoboxing du résultat
Integer resultatMultiplication = i * j;
Integer resultatAddition = i + j;
Integer resultatSoustraction = i - j;
Integer resultatDivision = i / j;
}
{
//Autoboxing dans la déclaration
//Unboxing partout ailleurs
for (Integer i = 0; i<150; i++) {
System.out.println(i);
}
}
Il y a encore une remarque à faire pour l’unboxing.
En effet, tout comme un objet peut être initialisé à null, on peut avoir un Boolean, Integer ou Character à null:
Boolean b = null;
Integer i = null;
Character c = null;
Lors de l’unboxing
boolean b2 = b;
int i2 = i;
char c2 = c;
On aura en fait une NullPointerException qui sera levée.
6 Commentaires + Ajouter un commentaire
Commentaires récents
Archives
- janvier 2012
- novembre 2010
- février 2009
- janvier 2009
- décembre 2008
- septembre 2008
- août 2008
- décembre 2007
- octobre 2007
- septembre 2007
- juillet 2007
- mai 2007
- avril 2007
- mars 2007
- février 2007
- janvier 2007
- décembre 2006
- novembre 2006
- octobre 2006
- septembre 2006
- août 2006
- juillet 2006
- juin 2006
- mai 2006
- avril 2006
- février 2006
- janvier 2006
- décembre 2005
- novembre 2005
- octobre 2005
- septembre 2005
- août 2005
- juillet 2005
- juin 2005
- mai 2005
- avril 2005
Catégories
- Certification
- Défis
- Devoxx
- Devoxx 2008
- Devoxx 2010
- Devoxx France 2012
- Divers
- Événements Java
- Fiches
- Hardware
- In English
- Java
- JavaDay 2006
- JavaFX
- JavaOne 2005
- JavaOne 2006
- JavaOne 2007
- Javapolis 2005
- Javapolis 2006
- Javapolis 2007
- JBoss
- Livres
- Mac
- NetBeans
- OpenJDK
- Pensée
- Performance
- Perles
- Sun Tech Days Paris 2007
- Traduction

Un article de vbrabant
très intéressant.
En lisant tout cela j’ai testé :
Integer a = 5;
int b = 5;
double c =5;
System.out.println(a==b);
System.out.println(b==a);
System.out.println(a==c);
System.out.println(c==a);
pour information cela renvoie vrai a chaque fois, de l’unboxing donc en cas de comparaison entre primitives et objets
merci beaucoup !!!
Très bonne fiche :). Avant de lire cette fiche, je n’y entendais rien en autoboxing. Maintenant c’est beaucoup plus clair. A manipuler avec beaucoup de précautions tout de même. L’exemple du lock est édifiant : l’autoboxing est dangereux si on ne sait pas parfaitement le manipuler.
Je sens que je vais me la relire une dizaine de fois à chaque auto ou unboxing que je ferai dans un programme :). Merci !
Oui je n’avais pas pensé à ce problème… en général j’utilise un simple Object comme lock.
a++
== et equals() fera le sujet d’une autre fiche. Et donc cela ne devrait pas être un problème.
Par contre, pour revenir au fait que cela ne devrait pas être un réel problème, j’aimerais raconter l’histoire suivante:
Des classes qui devaient supporter le multithreading. Et on crée un object lock, sur lequel on fait un synchronize, pour certaines méthodes. Et on crée un autre objet lock sur lequel on fait un synchronize, pour d’autres méthodes.
Les objets de locks étaient définis comme suit:
Byte lock1 = new Byte(0);
Byte lock2 = new Byte(0);
Et furent ensuite transformés, lors du passage vers JDK 5 en
Byte lock1 = 0;
Byte lock2 = 0;
Les deux locks pointaient maintenant vers les mêmes objets. Et donc le synchronize ne se passait plus du tout comme précédemment, et chute des performances, …
Bref, toujours faire attention.
Très intérréssant et complet…
Mais tu aurais du insister sur le fait que l’opérateur == s’effectue sur les références et que généralement on ne compare pas les références mais les valeurs avec .equals()
Donc ce ne devrait pas être un réel problème…
a++