这个方法用空检查比较两个Integer。请参阅测试。

public static boolean compare(Integer int1, Integer int2) {
    if(int1!=null) {
        return int1.equals(int2);
    } else {
        return int2==null;
    }
    //inline version:
       //return (int1!=null) ? int1.equals(int2) : int2==null;
}

//results:
System.out.println(compare(1,1));           //true
System.out.println(compare(0,1));           //false
System.out.println(compare(1,0));           //false
System.out.println(compare(null,0));        //false
System.out.println(compare(0,null));        //false
System.out.println(compare(null,null));        //true

No， == Integer, Long etc将检查引用是否相等。

Integer x = ...;
Integer y = ...;

System.out.println(x == y);

这将检查x和y是否指向相同的对象，而不是相同的对象。

So

Integer x = new Integer(10);
Integer y = new Integer(10);

System.out.println(x == y);

保证打印为false。“小”自动装箱值的实习可能会导致棘手的结果:

Integer x = 10;
Integer y = 10;

System.out.println(x == y);

根据装箱规则(JLS第5.1.7节)，这将输出true。它仍然使用了引用相等，但是引用实际上是相等的。

如果被装箱的值p是一个int类型的整型字面值 -128和127包括(§3.10.1)，或布尔字面值真或假(§3.10.3)，或'\u0000'和'\u007f'之间的字符字面值 包含(§3.10.4)，则设a和b是任意两个装箱的结果 a == b总是成立的。

我个人会使用:

if (x.intValue() == y.intValue())

or

if (x.equals(y))

正如您所说，对于包装器类型(Integer, Long等)和数字类型(int, Long等)之间的任何比较，包装器类型值将被打开，测试将应用于涉及的原语值。

这是二进制数字提升的一部分(JLS第5.6.2节)。查看每个操作符的文档，看看它是否适用。例如，从文档For ==和!= (JLS 15.21.1):

如果一个等式的操作数 运算符都是数值类型或 一个是数字类型，另一个是数字类型 是否可转换(§5.1.8)为数字 类型，二进制数字提升是 在操作数上执行(§5.6.2)。

and <， <=， > and >= (JLS 15.20.1)

a的每个操作数的类型 数值比较运算符必须是 可转换(§5.1.8)的类型 基元数字类型 发生编译时错误。二进制 上执行数字提升 操作数(§5.6.2)。如果升职了 操作数的类型是int或long， 那么有符号整数比较是 执行;如果此提升类型为 Float或double，然后是浮点数 进行比较。

请注意，在两种类型都不是数字类型的情况下，这些都不会被认为是情况的一部分。

==检查引用是否相等，但是当编写如下代码时:

Integer a = 1;
Integer b = 1;

Java足够聪明，可以为a和b重用相同的不可变变量，所以这是正确的:a == b。好奇的是，我写了一个小例子来说明Java停止以这种方式优化的地方:

public class BoxingLol {
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            Integer a = i;
            Integer b = i;
            if (a != b) {
                System.out.println("Done: " + i);
                System.exit(0);
            }
        }
        System.out.println("Done, all values equal");
    }
}

当我编译和运行这个(在我的机器上)，我得到:

Done: 128

从Java 1.7开始，你可以使用Objects.equals:

java.util.Objects.equals(oneInteger, anotherInteger);

如果参数相等则返回true，如果参数为false则返回false 否则。因此，如果两个参数都为空，则返回true 如果恰好有一个参数为null，则返回false。否则, 等号是用第一个的等号法来确定的 论点。

调用

if (a == b)

大部分时间都有效，但不能保证总是有效，所以不要使用它。

比较两个Integer类是否相等的最合适的方法是，假设它们分别命名为'a'和'b'，调用:

if(a != null && a.equals(b)) {
  System.out.println("They are equal");
}

你也可以用这种稍微快一点的方法。

   if(a != null && b != null && (a.intValue() == b.intValue())) {
      System.out.println("They are equal");
    } 

在我的机器上，使用第一种方法执行990亿次操作需要47秒，使用第二种方法需要46秒。您需要比较数十亿个值才能看到任何差异。

注意，'a'可能是空的，因为它是一个对象。以这种方式进行比较不会导致空指针异常。

用于比较大于和小于，使用

if (a != null && b!=null) {
    int compareValue = a.compareTo(b);
    if (compareValue > 0) {
        System.out.println("a is greater than b");
    } else if (compareValue < 0) {
        System.out.println("b is greater than a");
    } else {
            System.out.println("a and b are equal");
    }
} else {
    System.out.println("a or b is null, cannot compare");
}

==仍然测试对象是否相等。然而，这很容易被愚弄:

Integer a = 10;
Integer b = 10;

System.out.println(a == b); //prints true

Integer c = new Integer(10);
Integer d = new Integer(10);

System.out.println(c == d); //prints false

你使用不等式的例子是可以工作的，因为它们不是在对象上定义的。但是，使用==比较时，仍然会检查对象是否相等。在这种情况下，当你从一个盒装的原语中初始化对象时，使用了相同的对象(对于a和b)。这是一个不错的优化，因为原语盒类是不可变的。