Qual è la differenza tra (intero) y e nuovo numero intero (y) in java?

Question

Qual è la differenza tra i seguenti:

Integer in = (Integer)y;

e

Integer in = new Integer(y);

voglio convertire int tipo di Integer tipo e viceversa. Ecco il mio codice per farlo:

public class CompareToDemo { 

    public static void main(String[] args) { 
    // Integer x=5; 
    int y=25; 

    System.out.println(y+" this is int variable"); 

    Integer in = (Integer)y; 

    //Integer in = new Integer(y); 

    if(in instanceof Integer){ 
     System.out.println(in +" this is Integer variable"); 
    } 
    } 
} 

Answer 1

Se tutto quello che vogliamo fare è quello di convertire un int primitivo a un oggetto Integer, si hanno quattro opzioni

Integer in = (Integer)y;   // 1 explicit cast 
    Integer in = y;     // 2 implicit cast (autoboxing) 
    Integer in = new Integer(y);  // 3 explicit constructor 
    Integer in = Integer.valueOf(y); // 4 static factory method 

Il modo più preferibile qui è 2 (autoboxing). Il costruttore esplicito (3) è il meno preferibile, in quanto potrebbe avere qualche piccolo impatto sulle prestazioni.

Inoltre, non sono strettamente equivalenti. Si consideri:

public static void main(String[] args) { 
    int x = 25; 
    Integer a = new Integer(x); 
    Integer b = new Integer(x); 
    System.out.println(a == b);  // false 
    Integer c = Integer.valueOf(x); 
    Integer d = Integer.valueOf(x); 
    System.out.println(c == d);  // true 
    Integer e = (Integer)x; 
    Integer f = (Integer)x; 
    System.out.println(e == f);  // true 
} 

Questo perché interi piccoli vengono memorizzati nella cache (details here).

Answer 2

Per dirla in breve,

• La linea Integer in = (Integer)y; utilizza un cast inutile.
• La riga Integer in = new Integer(y); crea un'istanza Integer.

---

Ogni caso in dettaglio

In primo luogo, prendiamo in considerazione il caso di cast esplicito.

Integer i = (Integer)10; 

Il compilatore capisce che 10 è un tipo primitivo int e il fatto che deve essere avvolto dal suo Integer per renderlo compila. Sembra javac farà la seguente:

Integer i = (Integer)Integer.valueOf(10); 

Ma il compilatore è abbastanza intelligente da fare fusione inutili, (Integer) appena verrà omessa:

Integer i = Integer.valueOf(10); 

Avanti, c'è il caso con la creazione dell'istanza.

Integer i = new Integer(10); 

Qui è tutto semplicemente. Una nuova istanza della classe Integer verrà comunque creata. Ma, come dice la documentazione, di solito, non è il modo appropriato:

Raramente è opportuno utilizzare questi costruttori. Gli stabilimenti statici valueOf() sono in genere una scelta migliore, poiché è probabile che producano prestazioni significativamente migliori in termini di spazio e tempo.

Conclusione

Nella scrittura di codice di tutti i giorni, usiamo di solito autoboxing and unboxing. Sono conversioni automatiche tra i tipi primitivi e le corrispondenti classi wrapper degli oggetti (è stato introdotto in Java 5). Quindi non è necessario pensare molto ai metodi Xxx.valueOf(xxx) e .xxxValue(). È così conveniente, no?

Integer i = 10; // autoboxing 
int j = i; // unboxing 

Answer 3

Per ogni primitive type in Java, v'è una corrispondente classe involucro. È possibile convertire tra questi tipi primitivi e le corrispondenti classi wrapper.Questo è chiamato boxing e unboxing. Quando si scrive

Integer in = (Integer)y; //this is unnecessary casting 

o

Integer in = new Integer(y); //create a new instance of Integer class 

si sta convertendo principalmente tra il tipo primitivo e classe wrapper. Ma Java ha una funzionalità chiamata Auto Boxing and Unboxing Dove java farà questo casting per te. Basta scrivere

int iPrimi = 20; 
Integer iWrapper = iPrimi; //Autoboxing 
int iPrimi2 = iWrapper; //Auto unboxing 

Autoboxing e Unboxing riducono le prestazioni. Primitives seems to be 2-3 times faster then it’s Integer equivalent. Quindi non usarli se non ne hai bisogno.