Pertama sekali, untuk dua (first == second), kerana pertama ialah int (jenis asas), apabila melakukan perbandingan ==, kedua akan dinyahkotak dari Integer kepada int, dan kemudian == akan melaksanakan nilai Perbandingan - Kerana dua nilai (kali pertama ialah 127, kali kedua ialah 128) adalah sama, jadi kedua-dua masa adalah true;

, kedua dan ketiga adalah kedua-duanya (second == third) (objek), jadi apabila membandingkan ==, apa yang dibandingkan ialah rujukan objek Jika kedua-dua rujukan menghala ke memori yang sama ( objek yang sama), kemudian kembalikan Integer, jika tidak kembalikan true. Kod seperti false
sebenarnya adalah gula sintaksis untuk Java Apa yang sebenarnya dilaksanakan ialah second = 127; Mari kita lihat kod sumber second = Integer.valueOf(127): Integer.valueOf
<.> mudah difahami.

IntegerCache.low ~ IntegerCache.high, jadi jika parameter integer yang saya luluskan berada dalam julat ini, maka objek yang dicache akan dikembalikan, jika tidak, baru saja mencipta baharu Integer. Pada JVM Oracle, julat cache lalai Integer ialah -128 ~ 127. Jadi setiap panggilan ke Integer mengembalikan Integer cache yang sama dan panggilan Integer.value(127) akan mencipta Integer baharu setiap kali. Jadi yang pertama Integer.value(128) mengembalikan benar dan yang kedua mengembalikan palsu. Integer（new Integer(128)）

Dua jenis Ineger dibandingkan dengan ==. Jika nilai adalah antara -128~127, ia mengembalikan benar, jika tidak ia mengembalikan palsu Ini disebabkan oleh objek penimbal 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.
     */

• Perbandingan antara objek akan menjejaskan keputusan disebabkan penimbalan dalam julat tertentu.

• Perbandingan antara kelas berpakej (objek) dan jenis asas ialah nisbah langsung untuk mendapatkan hasilnya.