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?
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