Come funziona il java auto boxing / unboxing?

Dal momento che JDK 5.0 è stato introdotto in java, il trucco e l’inscatolamento automatico sono stati introdotti in java, ma quando ho iniziato a testare diverse conversioni tra classi wrapper e tipi primitivi, sono davvero confuso su come funziona il concetto di boxing automatico 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 accettato dal compilatore è quando il tipo del valore a destra dell’operatore dell’affettività è int . Quando ho guardato all’interno del sorgente di Integer.class ho scoperto che implementa solo un costruttore con parametro int .

Quindi la mia conclusione è che il concetto di auto boxing si basa sul costruttore implementato nella class wrapper. Voglio sapere se questa conclusione è vera o esiste un altro concetto utilizzato dal boxing automatico?

unboxing

 Integer intObject = new Integer(0); byte byteValue = intObject; // ==> Error (the same Error with short) int intValue = intObject; double doubleValue = intObject; 

La mia conclusione su unboxing è che la class wrapper fornisce il valore racchiuso dall’object nel tipo corrispondente ( Integer ==> int ), quindi il compilatore usa le solite regole di conversione dei tipi primitivi ( byte => short => int => long => float => double ). Voglio sapere se questa conclusione è vera o esiste un altro concetto utilizzato dall’auto-unboxing?

Grazie in anticipo 🙂

In caso di dubbio, controlla 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() viene usato in opposizione al costruttore (e lo stesso vale per le altre classi wrapper). Ciò è utile poiché consente la memorizzazione nella cache e non impone la creazione di un nuovo object su ciascuna operazione di box.

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 

vale a dire intValue() viene utilizzato (di nuovo, è analogo per gli altri tipi di wrapper). Questo è davvero tutto il pugilato automatico (un) si riduce a.

Puoi leggere le conversioni di boxing e unboxing rispettivamente in JLS §5.1.7 e JLS §5.1.8 .

Boxing automatico e unboxing automatico

Il pugilato automatico significa che quando proviamo ad assegnare un dato primitivo a un tipo di object, esso si converte automaticamente nel tipo di object. Questo processo si chiama auto boxing .. e quando un tipo di object converte nel tipo primitivo è chiamato unboxing … cerca di capire 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 per il pugilato automatico

 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 per l’unbox automatico

 class Demo{ public static void main(String args[]){ Integer iob=new Integer(100); int x=iob; //Auto unboxing ==>Assignment } 

}

grazie..

Considera il seguente codice come esempio di un-boxing automatico:

 System.out.println('b'+ new Integer(63)); 

Ecco una ripartizione di come viene compilato il codice precedente:

Passo 1: Oggetto Integer 63 viene istanziato e quindi AUTO-UNBOXED su int 63

 new Integer(63) 

Passaggio 2: char ‘b’ viene convertito in valore numerico, ad esempio 98

Passaggio 3: vengono aggiunti i due valori: 98 + 63

Passaggio 4: l’output è 161