Java: qual è la differenza tra autoboxing e casting?

Questa domanda riguarda “Perché l’autoboxing rende alcune chiamate ambigue in Java?”

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

Qualcuno può fornire una spiegazione semplice?

La boxe è quando converti un tipo primitivo in un tipo di riferimento, il non-boxing è 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.

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

Il casting è un termine generico con due significati correlati ma diversi:

  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 class B estende la class A , puoi chiedere a myB un’istanza di B di essere trattata come un’istanza di A scrivendo ((A) myB) ovunque possa comparire 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 object da una collezione. Ad esempio, se avessi memorizzato una String in una Map e avessi bisogno di ottenere la sua lunghezza, dovresti scrivere qualcosa come ((String) myMap.get(someKey)).length() dove il cast sarebbe richiesto per chiamare il metodo di length di String . Di nuovo, questo non causa la creazione di una nuova String .

  2. Conversione esplicita di un tipo in 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) ) viene prodotto dall’altro valore mediante il calcolo interno.

Il cast può essere fatto quando c’è una superclass / sottoclass o una relazione interfaccia / implementatore (che significa 1 sopra) o quando i due tipi sono tipi numerici primitivi (che significa 2). Potresti cercare “allargando” e “restringendo” per maggiori dettagli.

La boxe si riferisce al wrapping di tipi primitivi in ​​oggetti contenitore, solitamente solo quando è necessario disporre di un object (ad esempio, memorizzare un valore in una raccolta). I tipi primitivi e di wrapper sono disponibili in coppie:

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

Unboxing significa semplicemente recuperare il valore primitivo dall’interno del suo object wrapper.

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

Quindi, 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; 

tu puoi scrivere:

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

e il codice box / unboxing è inserito dal compilatore.

 List list = (List)object; 

è un cast.

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

è auto-boxing.

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

è auto-unboxing.

Autoboxing è stato introdotto in Java 5 per prevenire codice come:

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

Adesso puoi dire:

 map.put("ABC", 5); 

Mentre è più facile – ha qualche insidia se non sei completamente sicuro di quello che stai facendo.

La boxe sta avvolgendo un valore all’interno di un contenitore, come un valore primitivo int all’interno di un object intero

Il casting è solo come guardare il tipo.

Il primo produce un altro tipo di valore, il successivo modifica semplicemente come trattare un valore già esistente

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

Boxing e Unboxing è un tipo di cast in Java, in cui si esegue il cast da una primitiva alla sua class wrapper o inversa, ad esempio da booleano a booleano (casella) o da booleano a booleano (unbox).

Tipi di cast in Java, con esempio:

  • una conversione di identity framework (§5.1.1) Da stringa a stringa

  • un ampliamento della conversione primitiva (§5.1.2) da byte a int

  • una restringente conversione primitiva (§5.1.3) int a byte

  • una conversione di riferimento allargata (§5.1.5) Intero al numero

  • una conversione di riferimento restringente (§5.1.6) Numero a numero intero

  • una conversione di boxe (§5.1.7) int a Integer

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

Autoboxing o autounboxing avviene quando il compilatore esegue la conversione boxing / unboxing per te (non appare esplicitamente nel codice sorgente come espressione cast), ad esempio vedi la domanda a cui ti sei riferito.

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