Java: qual è la differenza tra autoboxing e casting?

Question

This question riguarda "Perché la funzione di autoboxing rende alcune chiamate ambigue in Java?"

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

Qualcuno può fornire una spiegazione semplice?

Answer 1

La boxing è quando si converte un tipo primitivo in un tipo di riferimento, la spunta fuori è il contrario. La trasmissione è quando si desidera che un tipo venga trattato come un altro tipo, tra tipi primitivi e tipi di riferimento questo significa un'operazione di boxing implicita o esplicita. Se deve essere esplicito è una caratteristica del linguaggio.

Answer 2

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

è un cast.

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

è auto-boxing.

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

è auto-unboxing.

Answer 3

Autoboxing è stato introdotto in Java 5 per evitare che codice come:

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

Si può ora dire:

map.put("ABC", 5); 

Mentre è più facile - se ha un paio di insidie ​​se non si è completamente sicuro di quello che stai facendo.

Answer 4

Boxing sta avvolgendo un valore all'interno di un contenitore, come ad esempio un valore di base int all'interno di un oggetto Integer

Casting è proprio come guardare il tipo.

La prima produce un altro tipo di valore, la modifica in seguito semplicemente come trattare un valore già esistente

Tranne fusione tra tipi primitivi modifica effettivamente la loro rappresentazione. (Questo non lo rende più chiaro?)

Answer 5

Il boxing e unboxing è 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 calchi in Java, con esempio:

• una conversione di identità (§5.1.1) corda a corda

• un allargamento di conversione primitiva (§5.1.2) byte int

• un restringimento conversione primitiva (§5.1.3) int a byte

• una conversione riferimento allargamento (§5.1.5) integer Numero

• una conversione riferimento restringimento (§5.1.6) Numero di Integer

• una conversione di boxe (§5.1.7) int al numero intero

• una conversione unboxing (§5.1.8). Integer a int

Autoboxing o autounboxing accade quando il compilatore fa il/la conversione unboxing boxe per voi (non appare esplicitamente nel codice sorgente come espressione getto), ad esempio, vedi la domanda a cui ti sei riferito.

Answer 6

Sia casting che box/unboxing hanno a che fare con tipi e conversioni apparenti (o reali), ma boxing/unboxing è specifico della relazione tra tipi primitivi e tipi di wrapper corrispondenti, mentre casting è il termine esplicito o implicito cambiamento di tipo in senso più generale.

Casting è un termine generico con due significati correlati ma differenti-:

1. Trattare 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, è possibile richiedereun'istanza di B da trattare come un'istanza di A scrivendo ((A) myB) ovunque possa essere visualizzato un riferimento a un'istanza di A. Questo in realtà non produce una nuova istanza di A.

   1.2. Le collezioni Pre-Java5 memorizzavano tutto il contenuto come Object; questo di solito richiedeva di usare un cast dopo aver recuperato un oggetto da una collezione. Ad esempio, se hai memorizzato un numero String in un Map e hai bisogno di ottenere la sua lunghezza, dovresti scrivere qualcosa come ((String) myMap.get(someKey)).length() dove il cast sarebbe richiesto per chiamare il metodo Stringlength. Anche in questo caso, ciò non causa la creazione di un nuovo String.

2. Esplicitamente un tipo a un altro (cioè modifica esplicita della rappresentazione). Un esempio di questo secondo utilizzo è nell'espressione ((int) (float_var + 0.5F)) che arrotonda una variabile in virgola mobile aggiungendo 0,5 (che produce un valore in virgola mobile) e quindi convertendo esplicitamente tale valore in un numero intero. Il valore intero risultante (dopo il cast (int)) è prodotto dall'altro valore tramite il calcolo interno.

Casting può essere fatto quando c'è una superclasse/sottoclasse o rapporto interfaccia/implementatori (cioè 1 sopra) o quando i due tipi sono primitivi tipi numerici (significato 2). Potresti cercare "allargando" e "restringendo" per maggiori dettagli.

Il boxing si riferisce al wrapping di tipi primitivi in ​​oggetti contenitore, in genere eseguiti solo quando è necessario disporre di un oggetto (ad esempio, memorizzare un valore in una raccolta).I tipi primitivi e involucro in coppie:

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

Unboxing significa semplicemente recuperare il valore primitivo dall'interno suo involucro oggetto.

A partire da Java5, quando si scrive un'espressione che utilizza un valore primitivo in cui è richiesto il corrispondente tipo di wrapper (come l'inserimento di un intero in una raccolta), il compilatore inserisce automaticamente il codice che racchiude effettivamente quel valore primitivo . Allo stesso modo fornirà il codice unwrapping per te.

Così, invece di scrivere (in pre-Java5) qualcosa come:

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

si può scrivere:

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

e il codice di boxe/unboxing è inserito dal compilatore.

Answer 7

È possibile applicare Autoboxing e Unboxing 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");