Salut tout le monde,

je ne comprends pas l'utilité des classes enveloppes, à quoi elle peuvent servir alors qu'il y'a les types primitifs?

Et merci d'avance

Quand tu veux par exemple transformer un String en un int tu fais comment ?

[edit] : faute de frappe -_-'

euh Je sais pas vraiment

Egalement pour le stockage dans les listes qui ne se fait que pour des objets, le passage de paramètre par adresse, alors que les primitifs sont par valeur, et sans doute encore plein d'autres choses...

Il faut également mentionner qu'il faut utiliser ces classes avec précaution. Effectivement, elles impliquent de nombreuses conversions et créations d'objets (autoboxing).

Citation : dod

Il faut également mentionner qu'il faut utiliser ces classes avec précaution. Effectivement, elles impliquent de nombreuses conversions et créations d'objets (autoboxing).

C'est d'autant plus vrai qu'elles sont immutables.

et pour convertir un String en int on fais comment?

tu parse (regarde la doc des ces classes)

Il faut savoir que les types primitifs int, double, boolean et autres ont depuis Java 1.5 je crois également leur propre classe. Pour le int c'est Integer, boolean c'est Boolean, .... Pour parser une String en int tu peux justement utiliser une méthode de l'Integer => Integer.valueOf(String s);

Cela permet également d'utiliser les types primitifs dans les Collection et autres.

Merci pour vos réponses
je met en résolu

Citation : shakhal

Citation : dod

Il faut également mentionner qu'il faut utiliser ces classes avec précaution. Effectivement, elles impliquent de nombreuses conversions et créations d'objets (autoboxing).

C'est d'autant plus vrai qu'elles sont immutables.

Veux-tu dire que les classes sont finales ?

Pour ce qui concerne les classes enveloppes, celles-ci nous permettent de manipuler des types primitifs (int, double, long) comme des objets. Ainsi, on va pouvoir appliquer des méthodes directement à nos objets et donc d'une certaine manière à nos types primitifs.

Integer monNombre = new Integer(18);

Ici, nous utilisons les classes enveloppes. On va encapsuler la valeur 18 à l'intérieur d'un objet de type Integer. Ainsi, on va créer un objet de type Integer à partir d'une valeur primitive. On parle aussi de boxing.

De plus, chacune des classes enveloppes disposent de méthodes permettant d'obtenir la valeur contenue dans un objet. Pour un objet de type Integer, cela sera : intValue(). LongValue() pour un objet de type Long.
On parlera ici d'unboxing.

Integer monNombre = new Integer(18);
System.out.println(monNombre.intValue());

Il faut savoir également que ces objets disposent de méthodes encore plus intéressantes permettant de convertir un objet de type Integer en String (par exemple). On pour pourra réaliser cela :

int nombre = 19;     
String chaine = String.valueOf(nombre);
System.out.println(chaine);

Pour convertir une chaîne en un type primitif, on peut procéder ainsi :

String chaine = "19";
int nombre = Integer.parseInt(chaine);
System.out.println(nombre);

Il faut également savoir que depuis le JDK 5.0, on peut parler d'autoboxing. Ce concept va nous permettre d'encapsuler des types primitifs et d'obtenir leurs valeurs plus facilement.

Integer monNombre = 18;
int unNombre = monNombre;

Ce qu'il se passe ici, c'est que dans la première instruction, un objet de type Integer va être automatiquement créer et la valeur 18 va être encapasuler automatiquement.

Pour la seconde instruction. La valeur encapsulée dans monNombre va être automatiquement affectée à unNombre. C'est comme si l'on avait fait monNombre.intValue().

Là où je disais qu'il fallait utiliser ces classes avec précaution, c'est avec un exemple comme celui-ci :

Integer UnNombre = 8;
Integer nombre = UnNombre + 14;

Ces instructions peuvent se révéler coûteuses. Effectivement, dans la seconde instruction, UnNombre est converti en un type primitif de type int puis nous effectuons la somme (8+14) et enfin le résultat de cette somme est converti en Integer.

Citation : dod

Citation : shakhal

Citation : dod

Il faut également mentionner qu'il faut utiliser ces classes avec précaution. Effectivement, elles impliquent de nombreuses conversions et créations d'objets (autoboxing).

C'est d'autant plus vrai qu'elles sont immutables.

Veux-tu dire que les classes sont finales ?

Non je veux dire immutable, c'est à dire qu'on ne peut pas modifier leurs attributs sans créer une nouvelle instance, par exemple:

Integer i = 10;
Integer i2 = i;
System.out.println(i == i2); // true
i2 = 20;
System.out.println(i == i2); // false

l'opérateur == testant l'égalité sur l'emplacement mémoire, on peut voir que changer la valeur de l'entier a provoqué une nouvelle allocation mémoire.

Exemple très intéressant. Donc oui, tu as raison c'est encore plus coùteux.

Cependant Java étant bien fait si 2 Integer alloué via litteral ont la même valeur, ils auront le même emplacement mémoire.

Par contre si alloué via un opérateur new, une nouvelle instance est crée.

Integer i = 10;
Integer i2 = 10;
System.out.println(i == i2);  //true
i2 = new Integer(10);
System.out.println(i == i2);  //false

Est-ce toujours le cas lorsque l'on n'utilise pas le mot clé new de voir que deux objets qui se voient attribuer la même valeur disposent du même emplacement mémoire ? Apparemment, cela dépend aussi de la jvm qui va implémenter différement en fonction des cas deux objets de la même valeur (à prendre avec des pincettes).

Non ce n'est pas toujours le cas, mais dans l'implémentation de sun de la JVM (pour les autres je sais pas) il existe un pool mémoire pour certaines classes immutables, comme String ou les Wrapper class, ainsi, si un objet avec cette valeur existe déjà, il suffit de faire pointer la nouvelle référence dessus.

Terrible. Merci beaucoup pour ces explications.