参考

how-to-properly-compare-two-integers-in-java

示例

    public static void main(String[] args) {
        // (1)
        Integer integer1 = 1;
        Integer integer2 = 1;
        // true
        System.out.println(integer1 == integer2);

        // (2)
        integer1 = 256;
        integer2 = 256;
        // !!!false
        //  If the value p being boxed is an integer literal of type int
        // between -128 and 127 inclusive (§3.10.1),
        // or the boolean literal true or false (§3.10.3),
        // or a character literal between '\u0000' and '\u007f' inclusive (§3.10.4),
        // then let a and b be the results of any two boxing conversions of p.
        // It is always the case that a == b.
        System.out.println(integer1 == integer2);

        // (3)
        // true
        System.out.println(integer1 == 256);

        // (4)
        integer1 = new Integer(1);
        integer2 = new Integer(1);
        // false
        System.out.println(integer1 == integer2);

        // (5)
        // false
        // 重载了运算符
        System.out.println(integer1 < integer2);

        // (6)
        Boolean b1 = new Boolean(false);
        Boolean b2 = new Boolean(false);
        // false
        System.out.println(b1 == b2);

        // (7)
        b1 = false;
        b2 = false;

        // true
        System.out.println(b1 == b2);
    }

要特别注意第(2)个例子那种情况, 解释在注释中!来源: 文档
从源码也可以看出原因, Integer i = 10 实际上是调用了 Integer i = Integer.valueOf(10), 所以在一些范围内的常量, 会导致引用指向同一个对象.

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

第(3)个例子又是true了, 因为256实际上被重用了, 大概是常量池的原因.
==运算符并没有对Integer, Long这些类型做重载, 所以它就是比较两个引用是否指向了同一个对象. 即便对于Boolean也是一样.