Nombre (entier, long, octet)

"Puisque les développeurs pouvaient proposer des classes décrivant des nombres, ils ont décidé d'être créatifs, comme de vrais développeurs."

"Tout d'abord, ils ont proposé une classe abstraite Number, à partir de laquelle Byte, Short, Integer, Long, Float et Double sont dérivés. Il a des méthodes qui aident à convertir les nombres en d'autres types numériques."

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

"Bien. Après tout, tu ne peux pas écrire ceci :"

Long x = 100000;
Integer y = (Integer) x;

"Oui, ces types ne sont pas primitifs. C'est pourquoi nous utilisons les méthodes de la classe Number :"

Long x = 100000;
Integer y = x.intValue();

"Mais il y a encore quelques éléments à prendre en compte. Comme Integer n'est pas un entier, les objets Integer ne peuvent pas être comparés à l'opérateur classique "==".

int x = 500;
int y = 500;
x == y; //true

Integer x = 500;
Integer y = 500;
x == y; //false
x.equals(y); //true

"Exactement. D'une manière ou d'une autre, je n'y ai pas pensé tout de suite."

"Mais il y a plus."

« Vous court-circuitez mes circuits ! Qu'y a-t-il d'autre ?

"Lorsque nous attribuons une valeur int à une variable Integer, la méthode Integer.valueOf est appelée :"

Integer x = 5;

Integer x = Integer.valueOf(5);

"Ouais, j'ai déjà compris ça à partir de l'exemple ci-dessus."

"Mais, la fonction valueOf ne crée pas toujours un nouvel objet Integer."

« Euh, qu'est-ce que tu veux dire par « pas toujours » ? »

"Il met en cache les valeurs de -128 à 127."

Integer x = 300;
Integer y = 300;
Integer z = 300;

Integer x = Integer.valueOf(300);
Integer y = Integer.valueOf(300);
Integer z = Integer.valueOf(300);

Integer x = 100;
Integer y = 100;
Integer z = 100;

Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
Integer z = Integer.valueOf(100);

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = 10;
Integer t = 10;

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = Integer.valueOf(10);
Integer t = Integer.valueOf(10);

"En d'autres termes, la situation est la suivante :"

1)  Si nous écrivons «new Integer()», alors nous sommes assurés d'obtenir un nouvel objet.

2)  Si nous appelons Integer.valueOf(), explicitement ou via l'autoboxing, la méthode peut renvoyer un nouvel objet ou un objet mis en cache si l'argument nombre est compris entre -128 et 127.

"Qu'y a-t-il de si terrible dans la méthode renvoyant un objet du cache?"

"Peu importe. Vous avez juste besoin de savoir que parfois, quand vous ne vous y attendez pas, les objets peuvent être égaux. Tout ce qui est égal est compliqué. Si nous comparons un primitif avec un non-primitif, alors ils sont comparés comme des primitifs :"

int x = 300;
Integer y = 300;
Integer z = 300;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references)

int x = 100;
Integer y = 100;
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //true (comparison based on references; they point to the same object)

int x = 100;
Integer y = new Integer(100);
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references; they point to different objects)

"Génial... Et comment vais-je mémoriser tout ça ?"

"Vous n'avez pas besoin de mémoriser cela. Vous avez juste besoin de comprendre comment tout cela est organisé et ce qui se passe réellement lorsqu'un primitif et son homologue non primitif entrent en jeu."

"Je vous recommande également de regarder les méthodes de la classe Integer. Elle contient plusieurs bonnes méthodes utiles. Vous avez même utilisé l'une d'entre elles assez souvent."

"Oui, je me souviens. Integer.parseInt();"