Tout d'abord, pour deux (first == second), car first est int (type de base), lors de l'exécution de la comparaison ==, second sera déballé de Integer à int, puis == effectuera la comparaison de valeurs - Parce que les deux valeurs​​(la première fois sont 127, la deuxième fois sont 128) sont égales, donc les deux fois sont true ;

, le deuxième et le troisième sont tous deux (second == third) (objets), donc lors de la comparaison de ==, ce qui est comparé est la référence de l'objet si les deux références pointent vers la même mémoire (la. même objet), puis retournez Integer, sinon retournez true. Un code comme false
est en fait du sucre syntaxique pour Java. Ce qui est réellement exécuté est second = 127;. Jetons un coup d'œil au code source de second = Integer.valueOf(127) : Integer.valueOf
<.> est facile à comprendre.

de IntegerCache.low ~ IntegerCache.high, donc si le paramètre entier que j'ai transmis se situe dans cette plage, alors l'objet mis en cache sera renvoyé, sinon je viens de créer un nouveau Integer. Sur la JVM d'Oracle, la plage de cache par défaut de Integer est -128 ~ 127. Ainsi, chaque appel à Integer renvoie le même Integer mis en cache, et l'appel à Integer.value(127) créera un nouveau Integer à chaque fois. Ainsi, le premier Integer.value(128) renvoie vrai et le second renvoie faux. Integer（new Integer(128)）

Deux types Ineger sont comparés avec ==. Si la valeur est comprise entre -128 et 127, elle renvoie vrai, sinon elle renvoie faux. Cela est dû à l'objet tampon de Integer.valueof().

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    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() {}
    }

    /**
     * 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.
     */

• La comparaison entre les objets affectera les résultats en raison de la mise en mémoire tampon dans une certaine plage.

• La comparaison entre la classe packagée (objet) et le type de base est un rapport direct pour obtenir le résultat.