我知道如果你将一个包装好的基本类型整数与一个常量进行比较，例如：
Integer a = 4;
if (a < 5)
a会自动拆箱，然后比较操作就可以正常运行。
但是，当你要比较两个封装的Integer对象时，想要比较相等性或大小关系怎么办呢？
Integer a = 4;
Integer b = 5;
if (a == b)
上面的代码会检查它们是否是同一个对象，还是在那种情况下自动拆箱？
那么下面的代码呢：
Integer a = 4;
Integer b = 5;
if (a < b)
?
Integer x = ...;
Integer y = ...;
System.out.println(x == y);
x和y是否引用同一个对象，而不是相等的对象。
因此，
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），或者是布尔字面值true或false（§3.10.3），或者是在'\u0000'和'\u007f'之间的字符字面量（§3.10.4），那么让a和b成为p的任意两个装箱转换的结果。总有一个情况是a == b。
个人建议使用：
if (x.intValue() == y.intValue())
或者
if (x.equals(y))
Integer、Long等）和数值类型（int、long等）之间的任何比较，包装器类型的值会被解包，并应用于涉及的原始值。这是作为二进制数推广的一部分发生的（JLS section 5.6.2）。查看每个单独运算符的文档，以查看是否应用了它。例如，从 == 和 != 的文档中可以看到 (JLS 15.21.1)：
如果相等操作符的操作数都是数值类型，或者其中一个是数值类型并且另一个可转换（§5.1.8）为数值类型，则在操作数上执行二进制数字提升（§5.6.2）。
而对于 <，<=，>和>= (JLS 15.20.1)
x.compareTo(y) < 0而不是x < y呢？ - Max Nanasy==仍然会测试对象相等性。 然而，很容易被欺骗：
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方法后的结果。 - Jon Skeetjava.util.Objects.equals(oneInteger, anotherInteger);
在比较两个整数时，我们应该始终使用equals()方法。这是推荐的做法。
如果我们使用==比较两个整数，那么只有在特定范围的整数值（从-128到127的整数）内才能正常工作，这是由于JVM的内部优化造成的。
请参阅示例：
案例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");
}
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
Integer值范围的行为是由Java语言规范强制规定的；请参考Jon Skeet的回答中的JLS引用。 - undefined== 检查引用相等性，但是当编写如下代码时:
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
简而言之，我的意见是在检查值相等时使用一元+触发其中一个操作数的拆箱，否则只需使用数学运算符。下面是理由：
已经提到过，Integer的==比较是身份比较，这通常不是程序员想要的，目标是进行值比较；尽管如此，我还是对如何最有效地进行比较进行了一些小小的科学研究，无论是在代码紧凑性、正确性还是速度方面。
我使用了通常的一堆方法：
public boolean method1() {
Integer i1 = 7, i2 = 5;
return i1.equals( i2 );
}
public boolean method2() {
Integer i1 = 7, i2 = 5;
return i1.intValue() == i2.intValue();
}
public boolean method3() {
Integer i1 = 7, i2 = 5;
return i1.intValue() == i2;
}
public boolean method4() {
Integer i1 = 7, i2 = 5;
return i1 == +i2;
}
public boolean method5() { // obviously not what we want..
Integer i1 = 7, i2 = 5;
return i1 == i2;
}
编译和反编译后得到了这段代码：
public boolean method1() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
return var1.equals( var2 );
}
public boolean method2() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method3() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method4() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method5() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2 == var1 ) {
return true;
} else {
return false;
}
}
正如您可以轻松地看到的那样，方法1调用Integer.equals()（显然），方法2-4会产生完全相同的代码，通过.intValue()解包值，然后直接进行比较，而方法5只触发一个身份比较，是比较值的不正确的方式。
由于（如JS已经提到的）equals()会产生开销（它必须执行instanceof和未检查的转换），当在紧密循环中使用时，方法2-4将以完全相同的速度工作，明显比方法1更好，因为HotSpot不太可能优化掉转换和instanceof。
其他比较运算符（例如</>）也是类似的 - 它们会触发拆箱，而使用compareTo()则不会 - 但这次，操作非常可优化，因为intValue()只是一个getter方法（被优化掉的主要候选人）。
int/.intValue() - 尽管对于一些人来说可能有点WTF（主要是那些从未使用过一元加号的人），但它可以明确和简洁地显示意图 - 它表明我们想要一个操作数的int值，同时强制另一个值解包。这也无疑与用于原始int值的常规i1 == i2比较最相似。i1 == +i2和i1 > i2样式的Integer对象，出于性能和一致性的原因。它还使代码可移植到原语而不需要更改除类型声明之外的任何内容。对我来说，使用命名方法似乎像引入语义噪声，类似于备受批评的bigInt.add(10).multiply(-3)样式。unary +（一元加号），请参见例如 https://dev59.com/O3E85IYBdhLWcg3wwWat - user719662equals调用的开销，JIT编译器应该将该调用的代码内联，然后通过窥孔优化生成与一元+技巧相等的本机代码。 - undefined调用
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");
}
在我的电脑上，使用第一种方法进行99亿次操作需要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");
}
null的Integer是否相等。我查找了类似的主题，但没有找到优雅的解决方案。我想出了一个简单的实用函数：public static boolean integersEqual(Integer i1, Integer i2) {
if (i1 == null && i2 == null) {
return true;
}
if (i1 == null && i2 != null) {
return false;
}
if (i1 != null && i2 == null) {
return false;
}
return i1.intValue() == i2.intValue();
}
// Considering null is less than not-null
public static int integersCompare(Integer i1, Integer i2) {
if (i1 == null && i2 == null) {
return 0;
}
if (i1 == null && i2 != null) {
return -1;
}
return i1.compareTo(i2);
}
因为比较方法必须基于类型int（x==y）或类Integer（x.equals(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]);
}
}
这个方法通过空值检查比较两个整数。请参见测试。
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
Objects.equals(x,y)方法，而不是自己编写代码。 - ryvantage
==而不是equals得到了正确的结果，这可能是因为装箱的数字被内部化或以其他方式被重复使用（作为编译器优化，可能是原因）。提问这个问题的原因是为了找出内部发生了什么，而不是看起来发生了什么。（至少我在这里的目的就是这样。） - Jim Pivarski