Java: Quelle est la différence entre l'autoboxing et le casting?

le casting et la boxe/unboxing ont tous deux à voir avec les types et la conversion apparente (ou réelle), mais la boxe/unboxing est spécifique à la relation entre les types primitifs et leurs types d'enveloppe correspondants, tandis que le casting est le terme pour le changement explicite ou implicite de type dans le sens plus général.

moulage est un terme général avec deux significations connexes mais différentes:

1. En traitant une valeur d'un type comme si c'était une valeur d'un autre type. Deux exemples de cette première utilisation sont:

   1.1. Étant donné que la classe B étend la classe A , vous pouvez demander que myB une instance de B soit traitée comme une instance de A en écrivant ((A) myB) partout où une référence à une instance de A pourrait apparaître. Cela ne produit pas réellement une nouvelle instance de A .

   1.2. Les collections pré-Java5 stockaient tout le contenu sous la forme Object , ce qui vous obligeait généralement à utiliser un moulage après avoir récupéré un objet d'une collection. Par exemple, si vous aviez stocké un String dans un Map et que vous deviez obtenir sa longueur, vous écririez quelque chose comme ((String) myMap.get(someKey)).length() où le moulage serait requis pour appeler la méthode length de String . Encore une fois, cela n'entraîne pas la création d'un nouveau String .

2. explicitement conversion d'un type à un autre (c'est-à-dire modification explicite de la représentation). Un exemple de cette seconde utilisation est dans l'expression ((int) (float_var + 0.5F)) qui arrondit une variable à virgule flottante en ajoutant 0,5 (qui produit une valeur à virgule flottante) puis en convertissant explicitement cette valeur en un entier. La valeur entière résultante (après la fonte (int) ) est produit de l'autre valeur par un calcul interne.

le moulage peut être fait lorsqu'il y a un rapport superclasse/sous-classe ou interface/implementor (signification 1 ci-dessus) ou lorsque les deux types sont des types numériques primitifs (signification 2). Vous pouvez chercher "élargissement" et "rétrécissement" pour plus de détails.

Boxe se réfère à l'enrobage de type primitif dans un conteneur d'objets, habituellement fait seulement lorsque vous devez avoir un objet (par exemple, le stockage de une valeur dans une collection). Les types primitif et wrapper viennent par paires:

int      Integer
long     Long
boolean  Boolean
...      ...

Unboxing signifie simplement récupérer la valeur primitive de l'enveloppe de l'objet.

à partir de Java5, lorsque vous écrivez une expression qui utilise une valeur primitive où le type de wrapper correspondant serait requis( comme mettre un entier dans une collection), le compilateur glisse automagiquement dans le code qui enveloppe réellement cette valeur primitive. De même, il fournira le code de déballage pour vous.

donc au lieu d'écrire (en pré-Java5) quelque chose comme:

Map myMap = new HashMap();
...
myMap.put(someKey,Integer.valueOf(3));
...
int nextValue = (myMap.get(someKey)).intValue() + 1;

vous pouvez écrire:

Map<KeyType,Integer> myMap = new HashMap<KeyType,Integer>();
...
myMap.put(someKey,3);
...
int nextValue = myMap.get(someKey) + 1;

et le code de boxe/déboxage est inséré par le compilateur.

List<String> list = (List<String>)object;

est un plâtre.

void doSomething(Integer i) { ... }
...
doSomeething(5);

est de l'auto-boxe.

Integer getSomething();
...
int i = getSomething();

est auto-unboxing.

Autoboxing a été introduit en Java 5 pour empêcher le code tel que:

map.put("ABC", new Integer(5));
map.put("DEF", new Integer(6));

vous pouvez maintenant dire:

map.put("ABC", 5);

, Tandis que son plus facile - il comporte quelques pièges, si vous n'êtes pas complètement sûr de ce que vous faites.

la Boxe est la recouvrant d'une valeur à l'intérieur d'un conteneur, comme une int valeur primitive à l'intérieur d'un objet Integer

Casting est juste comment regarder le type.

le premier produit un autre type de valeur ,le dernier modifie juste comment traiter une valeur déjà existante

sauf casting entre types primitifs modifie en fait leur représentation. (Cela ne rend pas plus clair n'est-ce pas?)

Boxing and unboxing est un type de cast en Java, où vous cast d'une primitive à sa classe de wrapper ou l'inverse, par exemple booléen à booléen (box), OU booléen à booléen (unbox).

Types de distributions en Java, avec exemple:

• une conversion d'identité (§5.1.1) Chaîne à chaîne

• un élargissement des primitives de conversion (§5.1.2) byte int

• une conversion primitive rétrécissante (§5.1.3) int byte

• une conversion de référence d'élargissement (§5.1.5) Entier au numéro

• une conversion de référence de rétrécissement (§5.1.6) Nombre à Entier

• une conversion de boxe (§5.1.7) int À entier

• une conversion unboxing (§5.1.8). Nombre entier à int

l'autoboxing ou autounboxing se produit lorsque le compilateur ne le boxing/unboxing de conversion pour vous (n'apparaissent explicitement dans le code source comme une expression cast), voir, par exemple, la question a été renvoyé.

est-ce que L'Autoboxing et le Unboxing peuvent être appliqués dans le cas suivant ?

Long one = 10;
long two = 15;
Long three = 20;

if(one == three) //will this be unboxed or do we need to put a explicit
                 //condition like if(one.intValue() == three.intValue()) 
   System.out.println("Equal");
else 
   System.out.println("Not Equal");  


if(one == two) //will this be unboxed or do we need to put a explicit
               //condition like if(one.intValue() == two) 
   System.out.println("Equal");
else 
   System.out.println("Not Equal");