如何在Java中正确比较两个Integer？

我知道，如果将装箱的原始整数与常量进行比较，例如：

Integer a = 4;
if (a < 5)

a 将自动取消装箱，比较将起作用。

但是，当您比较两个装箱的Integers并且想要比较等于或小于/大于/大于时，会发生什么？

Integer a = 4;
Integer b = 5;

if (a == b)

上面的代码是否会导致检查它们是否是同一对象，或者在这种情况下会自动拆箱？

关于什么：

Integer a = 4;
Integer b = 5;

if (a < b)

？

不，在Integer，Long等之间==，将检查引用是否相等 -即

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。对“小的”自动装箱的值进行internet可能会导致棘手的结果：

Integer x = 10;
Integer y = 10;

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

true根据装箱规则（JLS第5.1.7节），将进行打印。它仍然使用引用相等，但是引用实际上是相等的。

如果要装箱的值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第5.6.2节）。查看每个操作员的文档以查看是否适用。例如，从文档为==和!=（JLS 15.21.1）：

如果相等运算符的操作数都是数字类型，或者一个是数字类型，而另一个是可转换的（第5.1.8节）为数字类型，则对操作数（第5.6.2节）执行二进制数字提升。

和<，<=，>和>=（JLS 15.20.1）

数值比较运算符的每个操作数的类型必须是可转换（第5.1.8节）为原始数值类型的类型，否则会发生编译时错误。对操作数（第5.6.2节）执行二进制数值提升。如果操作数的提升类型为int或long，则执行带符号整数比较；否则，将执行整数比较。如果此提升的类型为float或double，则执行浮点比较。

请注意，这两种类型都不属于数字类型。

==仍将测试对象是否相等。很容易上当，但是：

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）。这是可以的优化，因为基本框类是不可变的。

从Java 1.7开始，您可以使用Objects.equals：

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

如果参数彼此相等，则返回true；否则返回false。因此，如果两个参数都为null，则返回true；如果正好一个参数为null，则返回false。否则，将使用第一个参数的equals方法确定相等性。

== 检查引用是否相等，但是在编写类似以下代码时：

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

tl; dr我的意见是+在检查值相等时使用一元触发操作数之一上的拆箱操作，否则简单地使用数学运算符。基本原理如下：

已经提到过，==用于比较的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将以完全相同的速度工作，值得注意的是，在紧密循环中使用时，方法2-4比方法1更好，因为HotSpot并非如此可能优化演员和演员instanceof。

与其他比较运算符（例如</ >）非常相似-它们将触发拆箱，而compareTo()不会使用--但这一次，HS高度优化了该操作，因为intValue()这只是一种吸气方法（被优化的主要候选者）。

在我看来，将很少使用的版本4是最简洁的方式-每一个经验丰富的C / Java开发人员都知道，一元加在大多数情况下等于投地int/ .intValue()-虽然它可能是一个小WTF的某一时刻（主要是那些谁没（在其生命周期中不使用一元加号），可以说它最清楚，最简洁地显示了其意图-它表明我们想要一个int操作数的值，同时也迫使另一个值取消装箱。毫无疑问，它也i1 == i2与用于原始int值的常规比较最为相似。

我出于性能和一致性的考虑，投票赞成i1 == +i2＆i1 > i2拒绝Integer对象的样式。它还使代码可移植到基元，而不更改类型声明以外的任何内容。使用命名方法似乎给我引入了语义干扰，类似于广受批评的bigInt.add(10).multiply(-3)样式。

呼唤

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");
}

我们应该始终使用equals（）方法比较两个整数，这是推荐的做法。

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

请参见示例：

情况1：

整数a = 100; 整数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。

整数a = 220; 整数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

我希望这有帮助。

就我而言，我必须比较两个Integers的相等性，使两者都可以null。搜索了类似的主题，没有发现任何适合的话题。想到了一个简单的实用程序功能。

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