这个方法用空检查比较两个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

因为比较方法必须基于类型int (x==y)或类Integer (x= (y))，并使用正确的操作符:

public class Example {

    public static void main(String[] args) {
        int[] arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<arr.length-1; j++)
            if((arr[j-1] != arr[j]) && (arr[j] != arr[j+1]))
                System.out.println("int>" + arr[j]);

        Integer[] I_arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<I_arr.length-1; j++)
            if((!I_arr[j-1].equals(I_arr[j])) && (!I_arr[j].equals(I_arr[j+1])))
                System.out.println("Interger>" + I_arr[j]);
    }
}

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

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)。这是一个不错的优化，因为原语盒类是不可变的。

我们应该总是使用equals()方法来比较两个整数。这是推荐的做法。

如果我们使用==比较两个整数，由于JVM的内部优化，这将适用于一定范围的整数值(从-128到127的整数值)。

请看例子:

案例1:

Integer a = 100;
Integer b = 100;

if (a == b) {
  System.out.println("a and b are equal");
} else {
  System.out.println("a and b are not equal");
}

在上述情况下，JVM从缓存池中使用a和b的值，并返回相同的对象实例(因此内存地址)的整数对象，我们得到两者相等。它是JVM为特定范围值所做的优化。

情况2:在这种情况下，a和b不相等，因为它没有从-128到127的范围。

Integer a = 220;
Integer b = 220;
   
if (a == b) {
  System.out.println("a and b are equal");
} else {
  System.out.println("a and b are not equal");
}

正确的方法:

Integer a = 200;             
Integer b = 200;  
System.out.println("a == b? " + a.equals(b)); // 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，然后是浮点数 进行比较。

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

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

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

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