Was ist der Unterschied zwischen (Integer) y und new Integer (y) in Java?

Question

Was ist der Unterschied zwischen der folgenden ist:

Integer in = (Integer)y;

und

Integer in = new Integer(y);

I int Typ Integer Typ konvertieren möchten, und umgekehrt. Hier ist mein Code für das zu tun:

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

Wenn alles, was Sie tun möchten, ist ein int primitiv zu einem Integer Objekt zu konvertieren, vier Optionen haben

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 

Die am meisten bevorzugte Art und Weise hier ist 2 (Autoboxing). Der explizite Konstruktor (3) ist weniger bevorzugt, da er einen kleinen Leistungseinbruch haben könnte.

Sie sind auch nicht genau gleichwertig. Bedenken Sie:

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 
} 

Dies liegt daran, kleine ganze Zahlen zwischengespeichert werden (details here).

Answer 2

Kurz gesagt,

• Die Linie Integer in = (Integer)y; verwendet eine unnötige gegossen. Die Zeile Integer in = new Integer(y); erstellt eine Integer Instanz.

---

Jeder Fall im Detail

Lassen Sie uns zunächst den Fall mit expliziten Gießen betrachten.

Integer i = (Integer)10; 

Der Compiler versteht, dass 10 ist eine int primitive Art und die Tatsache, dass es durch seine Integer gewickelt werden muss es kompiliert zu machen. Es scheint, wird Javac folgend machen:

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

Aber der Compiler ist intelligent genug, um unnötiges Casting zu tun, (Integer) wird nur verzichtet werden:

Integer i = Integer.valueOf(10); 

Als nächstes gibt es den Fall mit Instanz-Schöpfung.

Integer i = new Integer(10); 

Hier ist alles einfach. Eine neue Instanz der Klasse Integer wird trotzdem erstellt. Aber, wie die Dokumentation sagt, ist es in der Regel nicht angemessen:

Es ist selten angemessen, diese Konstruktoren zu verwenden. Die statischen Fabriken valueOf() sind im Allgemeinen eine bessere Wahl, da sie wahrscheinlich eine wesentlich bessere Raum- und Zeitleistung erbringen.

Fazit

Im täglichen Code schreiben, in der Regel wir autoboxing and unboxing verwenden. Sie sind automatische Konvertierungen zwischen den primitiven Typen und ihren entsprechenden Objekt-Wrapper-Klassen (wurde in Java 5 eingeführt). Sie müssen also nicht viel über die Methoden Xxx.valueOf(xxx) und .xxxValue() nachdenken. Es ist so bequem, oder?

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

Answer 3

Für jeden primitive type in Java, gibt es eine entsprechende Wrapper-Klasse. Sie können zwischen diesem primitiven Typ und der entsprechenden Wrapper-Klasse konvertieren.Dies wird Boxen und Unboxing genannt. Wenn Sie schreiben

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

oder

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

Sie sind in erster Linie zwischen primitivem Typ und Wrapper-Klasse zu konvertieren. Aber Java hat eine Funktion namens Auto Boxing and Unboxing wo Java diese Casting für Sie tun wird. Schreiben Sie einfach

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

Autoboxing und Unboxing verringern die Leistung. Primitives seems to be 2-3 times faster then it’s Integer equivalent. Also benutze sie nicht, wenn du es nicht brauchst.