Giava:Qual è la differenza tra autoboxing e casting?

Question

Questa domanda riguarda "Perché l'autoboxing rende ambigue alcune chiamate in Java?"

Ma leggendo le risposte, ci sono una serie di riferimenti al casting e non sono sicuro di aver compreso completamente la differenza.

Qualcuno può fornire una spiegazione semplice?

Answer 1

La boxe è quando si converte un tipo primitivo in un tipo di riferimento, il non-boxing è il contrario. Il casting è quando si desidera che un tipo venga trattato come un altro tipo, tra tipi primitivi e tipi di riferimento, ciò significa un'operazione di boxing implicita o esplicita. Se deve essere esplicito è una caratteristica del linguaggio.

Answer 2

Sia il casting che il boxing / unboxing hanno a che fare con i tipi e la conversione apparente (o reale), ma boxing / unboxing è specifico della relazione tra i tipi primitivi e i loro corrispondenti tipi di wrapper, mentre casting è il termine per cambiamento esplicito o implicito di tipo in senso più generale.

Casting è un termine generale con due significati correlati ma diversi:

1. Trattando un valore di un tipo come se fosse un valore di un altro tipo. Due esempi di questo primo utilizzo sono:

   1.1. Dato che la classe B estende la classe A, puoi chiedere a myB un'istanza di ((A) myB) di essere trattata come un'istanza di Object scrivendo String ovunque un riferimento a un'istanza di Map potrebbe apparire. Questo in realtà non produce una nuova istanza di ((String) myMap.get(someKey)).length().

   1.2. Le raccolte pre-Java5 hanno archiviato tutto il contenuto come length; questo di solito richiede di usare un cast dopo aver recuperato un oggetto da una collezione. Ad esempio, se avessi archiviato un ((int) (float_var + 0.5F)) in un (int) e avessi avuto bisogno di allungarlo, dovresti scrivere qualcosa come <=> dove il cast sarebbe richiesto per chiamare il metodo <=> di <= >. Ancora una volta, ciò non causa la creazione di un nuovo <=>.

2. Esplicitamente conversione un tipo in un altro (ovvero modifica esplicita della rappresentazione). Un esempio di questo secondo utilizzo è nell'espressione <=> che arrotonda una variabile in virgola mobile aggiungendo 0,5 (che produce un valore in virgola mobile) e quindi convertendo esplicitamente quel valore in un numero intero. Il valore intero risultante (dopo il <=> cast) viene prodotto dall'altro valore mediante calcolo interno.

Il cast può essere eseguito in presenza di una superclasse / sottoclasse o relazione interfaccia / implementatore (significato 1 sopra) o quando i due tipi sono tipi numerici primitivi (significato 2). Potresti cercare & Quot; allargando & Quot; e " restringimento " per maggiori dettagli.

Boxing si riferisce al wrapping dei tipi primitivi negli oggetti contenitore, in genere eseguiti solo quando è necessario disporre di un oggetto (ad es. memorizzazione di un valore in una raccolta). I tipi primitivi e wrapper sono disponibili in coppie:

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

Unboxing significa semplicemente recuperare il valore primitivo dal suo wrapper di oggetti.

A partire da Java5, quando si scrive un'espressione che utilizza un valore primitivo in cui sarebbe richiesto il tipo di wrapper corrispondente (come l'inserimento di un numero intero in una raccolta), il compilatore scivola automagicamente nel codice che avvolge effettivamente quel valore primitivo. Allo stesso modo fornirà il codice da scartare per te.

Quindi invece di scrivere (in pre-Java5) qualcosa del tipo:

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

puoi scrivere:

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

e il codice di inscatolamento / unboxing viene inserito dal compilatore.

Answer 3

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

è un cast.

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

è il boxing automatico.

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

è auto-unboxing.

Answer 4

L'autoboxing è stato introdotto in Java 5 per impedire codice come:

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

Ora puoi dire:

map.put("ABC", 5);

Sebbene sia più semplice, presenta alcune insidie ​​​​se non sei completamente sicuro di ciò che stai facendo.

Answer 5

La boxe racchiude un valore all'interno di un contenitore, come un valore int primitivo all'interno di un oggetto Integer

Il casting è proprio come guardare il tipo.

Il primo produce un altro tipo di valore, il secondo modifica semplicemente il modo in cui trattare un valore già esistente

Tranne che il casting tra tipi primitivi modifica effettivamente la loro rappresentazione. (Questo non lo rende più chiaro, vero?)

Answer 6

Boxing e unboxing sono un tipo di cast in Java, in cui si esegue il cast da una primitiva alla sua classe wrapper o inversa, ad es. da booleano a booleano (casella) o da booleano a booleano (unbox).

Tipi di cast in Java, con esempio:

• una conversione di identità (& # 167; 5.1.1) Da stringa a stringa

• una conversione primitiva allargante (& # 167; 5.1.2) byte in int

• una conversione primitiva restrittiva (& # 167; 5.1.3) int in byte

• una conversione di riferimento allargante (& # 167; 5.1.5) Integer to Number

• una conversione di riferimento di restringimento (& # 167; 5.1.6) Numero da intero

• una conversione di boxe (& # 167; 5.1.7) int a Integer

• una conversione unboxing (& # 167; 5.1.8). Intero in int

L'autoboxing o l'autounboxing si verificano quando il compilatore esegue la conversione boxing / unboxing per te (non appare esplicitamente nel codice sorgente come espressione cast), ad es. vedi la domanda a cui ti riferivi.

Answer 7

Autoboxing e Unboxing possono essere applicati nel seguente caso?

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");