Zusammenfassung der detaillierten Analyse des Unterschieds zwischen Integer und Int in Java

Warum verwenden Java-Generika, wie im obigen Artikel erwähnt, Objekte anstelle von primitiven Typen? Aber ich verstehe den Unterschied zwischen Integer und int immer noch nicht ganz, also bin ich auf Baidu gegangen und habe einen Artikel von einem tollen Kerl gefunden, den ich ziemlich gut fand, also habe ich ihn erneut gepostet und geteilt.

Der Unterschied zwischen Integer und int

Integer ist die von int bereitgestellte Kapselungsklasse, und int ist der grundlegende Datentyp von Java Integer ist null und der Standardwert von int ist 0; als Integer deklarierte Variablen müssen instanziiert werden, während als Integer deklarierte Variablen kein Objekt sind und eine Referenz verwendet wird, um auf dieses Objekt zu verweisen. während int ein Basistyp ist und Werte direkt speichert.

Neben der Kenntnis des grundlegendsten Unterschieds zwischen Integer und int müssen Sie auch einige andere Probleme kennen, die bei der tatsächlichen Verwendung von Integer und int auftreten.
Ansonsten, wenn der Interviewer erneut fragt, ob Integer i = int ii = 1; Es wird geschätzt, dass einige Leute nicht in der Lage sein werden, darauf zu antworten. Wenn Sie andere Fragen stellen, werden schätzungsweise mehr Menschen verwirrt sein. Deshalb habe ich sie zusammengefasst und hoffe, dass sie für alle hilfreich sein wird.
Der Code lautet wie folgt:

public class Main {
 
    public static void main(String[] args) {
 
        int a = 128;
        Integer b = 127;
        Integer c = 127;
        Integer d = 128;
        Integer e = 128;
        Integer f = new Integer("128");
        Integer g = new Integer("127");
        Integer h = new Integer("127");
 
 
        //方案一（）
        System.out.println("方案一：Integer与new Integer不同初始化方法的值的比较,Integer与new Integer不会相等");
        //Integer e = 128;
        //Integer f = new Integer("128");
        if (e == f){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案二
        System.out.println("方案二：创建两个都是直接赋值的Integer");
        //Integer b = 127;
        //Integer c = 127;
        if (b == c){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        //Integer d = 128;
        //Integer e = 128;
        if (d == e){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案三
        System.out.println("方案三：两个都是new出来的Integer");
        //Integer g = new Integer("127");
        //Integer h = new Integer("127");
        if (g == h){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        System.out.println("---------------------");
 
        //方案四
        System.out.println("方案四：int与Integer比较");
        //int a = 128;
        //Integer f = new Integer("128");
        if (a == f){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
 
    }
}

Die laufenden Ergebnisse lauten wie folgt:

方案一：Integer与new Integer不同初始化方法的值的比较,Integer与new Integer不会相等
false
---------------------
方案二：创建两个都是直接赋值的Integer
true
false
---------------------
方案三：两个都是new出来的Integer
false
---------------------
方案四：int与Integer比较
true

Die Zusammenfassung lautet wie folgt:

Option 1:
Ich zuerst Behandeln Sie die beiden Objekte e und f. Verwenden Sie zwei verschiedene Initialisierungsmethoden, Integer und New Integer, um die beiden Objekte zu vergleichen.

Integer e = 128;
Integer f = new Integer("128");
 
if (e == f){
    System.out.println("true");
}else{
    System.out.println("false");
}

gibt das Ergebnis zurück: false
Schlussfolgerung: Integer und New Integer wird nicht gleich sein. Die Referenz von e zeigt auf den Heap, während f auf den Speicher (Konstantenpool) verweist, der für die Speicherung vorgesehen ist. Ihre Speicheradressen sind unterschiedlich, also falsch

Option 2:
Erstellen Sie beide direkt Die zugewiesene Ganzzahl vergleicht die beiden Objekte;

//Integer b = 127;
//Integer c = 127;
if (b == c){
    System.out.println("true");
}else{
    System.out.println("false");
}
//Integer d = 128;
//Integer e = 128;
if (d == e){
    System.out.println("true");
}else{
    System.out.println("false");
}

gibt das Ergebnis zurück:
wahr
falsch
und kommt zu dem Schluss: beiden wird eine Ganzzahl direkt zugewiesen, wenn die Zahl zwischen -128 und liegt 127, es ist wahr, andernfalls ist es falsch
Grund: Wenn Java Integer i2 = 128 kompiliert, wird es übersetzt in -> Integer i2 = Integer.valueOf(128) ;Die Funktion valueOf() wird zwischengespeichert die Zahlen zwischen -128 und 127

Wenn Sie sich den Quellcode ansehen, wird jeder verstehen, dass die Zahlen zwischen -128 und 127 zwischengespeichert werden. Wenn Ganzzahl b = 127, wird 127 beim nächsten Mal zwischengespeichert Wenn Sie Integer c = 127 schreiben, wird es direkt aus dem Cache entnommen und ist nicht neu.

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */
 
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
 
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
 
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
 
        private IntegerCache() {}
    }

Option drei:
Ich verwende zuerst die neue Integer-Initialisierungsmethode für die beiden Objekte g und h und vergleiche dann die beiden Objekte;

Integer g = new Integer("127");
Integer h = new Integer("127");
if (g == h){
    System.out.println("true");
}else{
    System.out.println("false");
}

gibt das Ergebnis zurück: false
Schlussfolgerung: Beide sind neue Integer-Objekte, die auf zwei verschiedene Integer-Objekte verweisen, beide sind falsch

Option 4:
Ich werde zuerst a überprüfen. Die beiden Objekte f verwenden zwei verschiedene Initialisierungsmethoden, int und new Integer, um die beiden Objekte zu vergleichen;

int a = 128;
Integer f = new Integer("128");
if (a == f){
    System.out.println("true");
}else{
    System.out.println("false");
}

gibt das Ergebnis zurück: true
und kommt zu dem Schluss: Der Vergleich von int und integer (ob neu oder nicht) ist wahr, weil Ganzzahl wird automatisch in int entpackt und dann verglichen

Verwandte Artikel:

Java-Tutorial – der Unterschied zwischen int und Ganzzahl

Detaillierte Erklärung des Unterschieds zwischen int und Integer in Java

Das obige ist der detaillierte Inhalt vonZusammenfassung der detaillierten Analyse des Unterschieds zwischen Integer und Int in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!