Jaka jest różnica między (Integer) yi nową Integer (y) w java?

Question

Jaka jest różnica między:

Integer in = (Integer)y;

i

Integer in = new Integer(y);

chcę przekonwertować int typ do Integer rodzaju i vice versa. Tu jest mój kodu za to, że:

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

Jeśli wszystko, co chcesz zrobić, to przekształcić int prymitywny do obiektu Integer, masz cztery opcje

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 

Najkorzystniejszym sposobem tutaj jest 2 (autoboxing). Konstruktor jawny (3) jest mniej preferowany, ponieważ może mieć niewielki wpływ na wydajność.

Ponadto nie są ściśle równoważne. Rozważmy:

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 
} 

To dlatego, że małe liczby całkowite są buforowane (details here).

Answer 2

Krótko mówiąc,

• Linia Integer in = (Integer)y; wykorzystuje niepotrzebnego obsady.
• Linia Integer in = new Integer(y); tworzy instancję Integer.

---

Każdy przypadek szczegółowo

Po pierwsze, rozważmy sprawę z wyraźną odlewu.

Integer i = (Integer)10; 

Kompilator rozumie, że 10 jest int prymitywny typ i fakt, że to musi być opakowane przez jego Integer aby kompiluje. Wydaje javac uczyni, co następuje:

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

Ale kompilator jest wystarczająco inteligentny, aby zrobić niepotrzebnego casting, (Integer) tylko zostaną pominięte:

Integer i = Integer.valueOf(10); 

Następny istnieje w przypadku tworzenia instancji.

Integer i = new Integer(10); 

Tutaj wszystko jest po prostu. Nowa instancja klasy Integer zostanie utworzona. Ale, jak wynika z dokumentacji, zwykle nie jest to właściwy sposób:

Rzadko należy używać tych konstruktorów. Statyczne fabryki valueOf() są generalnie lepszym wyborem, ponieważ zapewnią znacznie lepszą wydajność w czasie i przestrzeni.

Wnioski

W codziennego pisania kodu, zazwyczaj używamy autoboxing and unboxing. Są to automatyczne konwersje między typami pierwotnymi i odpowiadającymi im klasami pakowania obiektów (wprowadzone w języku Java 5). Więc nie musisz dużo myśleć o metodach Xxx.valueOf(xxx) i .xxxValue(). To takie wygodne, prawda?

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

Answer 3

Dla każdego primitive type Jawa istnieje odpowiednia klasa owinięcie. Możesz dokonać konwersji między tymi typami pierwotnymi a odpowiadającymi klasami otoki.To się nazywa boksowanie i rozpakowywanie. Kiedy piszesz

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

lub

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

Ty konwersja głównie między prymitywnym rodzaju i klasy otoki. Ale Java ma funkcję o nazwie Auto Boxing and Unboxing Gdzie java zrobi te casting dla ciebie. Po prostu napisz

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

Autoboxing i Unboxing obniżają wydajność. Primitives seems to be 2-3 times faster then it’s Integer equivalent. Więc nie używaj ich, jeśli nie potrzebujesz.