Come funziona java auto boxing/unboxing?
Dal momento che JDK 5.0, auto boxing / unboxing è stato introdotto in java, il trucco è semplice e utile, ma quando ho iniziato a testare diverse conversioni tra classi wrapper e tipi primitivi, mi sono davvero confuso su come funziona il concetto di auto boxing in java, ad esempio:
Boxe
int intValue = 0;
Integer intObject = intValue;
byte byteValue = 0;
intObject = byteValue; // ==> Error
Dopo aver provato diversi casi (short, long, float, double), l'unico caso che viene accettato dal compilatore è quando il tipo del valore sul diritto di affettazione l'operatore è int.
Quando ho guardato all'interno del sorgente di Integer.class ho scoperto che implementa solo un costruttore con il parametro int.
Quindi la mia conclusione è che il concetto di auto boxing si basa sul costruttore implementato nella classe wrapper. Voglio sapere se questa conclusione è vera o c'è un altro concetto usato da auto boxing?
Unboxing
Integer intObject = new Integer(0);
byte byteValue = intObject; // ==> Error (the same Error with short)
int intValue = intObject;
double doubleValue = intObject;
La mia conclusione sull'unboxing è che la classe wrapper fornisce il valore avvolto dall'oggetto nel tipo corrispondente (Integer ==> int), quindi il compilatore usa le solite regole per convertire i tipi primitivi(byte => short => int => long => float => double).
Voglio sapere se questa conclusione è vera o c'è un altro concetto utilizzato da auto unboxing?
Grazie per l'anticipo:)
3 answers
In caso di dubbio, controllare il bytecode:
Integer n = 42;
Diventa:
0: bipush 42
2: invokestatic #16 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
Quindi in realtà, valueOf() è usato al contrario del costruttore (e lo stesso vale per le altre classi wrapper). Ciò è utile poiché consente il caching e non forza la creazione di un nuovo oggetto su ogni operazione di boxe.
Il contrario è il seguente:
int n = Integer.valueOf(42);
Che diventa:
0: bipush 42
2: invokestatic #16 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: invokevirtual #22 // Method java/lang/Integer.intValue:()I
8: istore_1
Cioè. intValue() è usato (di nuovo, è analogo per l'altro anche i tipi di wrapper). Questo è davvero tutto auto (un)boxe si riduce a.
È possibile leggere le conversioni di boxe e unboxing in JLS §5.1.7e JLS §5.1.8, rispettivamente.
Auto boxing e auto unboxing
Auto boxing significa che quando proviamo ad assegnare un dato primitivo a un tipo di oggetto, si converte automaticamente nel tipo di oggetto.quel processo chiamato auto boxing.. e quando un tipo di oggetto si converte nel tipo primitivo, si chiama unboxing...cerca di capirlo dai seguenti esempi.
class Demo{
public static void main(String args[]){
int x=100;
//Integer iob=x; //Illegal jdk1.4
Integer iob=Integer.valueOf(x); //Legal at JDK1.4 =>Boxing
Integer iob2=x; //Legal JDK1.5 - Autoboxing
System.out.println(iob2);
}
}
Un altro esempio di auto boxing
class Demo{
public static void main(String args[]){
Integer iob=new Integer(100);
int x;
x=iob; //Legal => auto unboxing
System.out.println(x);
}
}
Esempio di unboxing automatico
class Demo{
public static void main(String args[]){
Integer iob=new Integer(100);
int x=iob; //Auto unboxing ==>Assignment
}
}
Grazie si..
Considera il seguente codice come esempio di auto un-boxing:
System.out.println('b'+ new Integer(63));
Ecco una ripartizione di come viene compilato il codice di cui sopra:
Passaggio 1: l'intero oggetto 63 viene istanziato e quindi UNBOXATO AUTOMATICAMENTE su int 63
new Integer(63)
Passaggio 2: il carattere ' b ' viene convertito in valore numerico, ovvero 98
Passaggio 3: vengono aggiunti i due valori: 98 + 63
Passo 4: L'uscita è 161