整数比较结果在Java中有所不同

我是一名Java程序员新手，遇到了一个非常奇怪的场景，如下所示

public static void main(String[] args) {
    Integer a = 500;
    Integer b = 500;

    // Comparing the values.
    a <= b; // true
    a >= b; // true
    a == b; // false

    // Reassigning the values
    a = 50;
    b = 50;

    // Again comparing the values.
    a <= b; // true
    a >= b; // true
    a == b; // true
}

publicstaticvoidmain（字符串[]args）{
整数a=500；
整数b=500；
//比较这些值。
a=b；//真
a==b；//错误
//重新分配值
a=50；
b=50；
//再次比较这些值。
a=b；//真
a==b；//真
}

---

我的问题是为什么

a==b

的结果会随着值的变化而变化？

这个问题的答案取决于对Java编程语言指定值的理解

a==b

的结果发生变化是因为

integer

类缓存了-128到127之间的任何整数。当创建此范围内的

int

时，将从

IntegerCache

检索它，而不是创建新的整数对象

这是虫子吗<当然不是

Java类Integer也称为包装器类，因为它提供了一个包装

int

基本数据类型的对象。在Java中，比较两个值对象不是直截了当的。我们应该重写

Object.equal

方法（以及

Object.hashCode

），并使用它来确定两个对象何时相等。在本例中，我们使用

==

操作符比较两个物理对象地址。Java需要新的操作符来创建对象，这些对象将全部存储在JVM的堆上。局部变量存储在JVM的堆栈上，但它们持有对对象的引用，而不是对象本身

在第一种情况下，当我们检查a==b时，我们实际上是在检查两个引用是否指向同一位置。答案是不

但当a&b是50岁时会发生什么？要回答这个问题，我们应该看看下面的

Integer.valueOf

方法

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

公共静态整数值（int i）{
如果（i>=-128&&i这个问题的答案在Java编程语言指定的理解范围内

a==b
结果的变化是因为-128到127之间的任何整数都被
integer
类缓存。当创建此范围内的
int
时，将从
IntegerCache
检索，而不是创建新的integer对象

这是一个bug吗？当然不是！

Java类Integer也称为包装器类，因为它提供了一个包装
int
基元数据类型的对象。在Java中，比较两个值对象不是直接的。我们应该重写
对象.equal
方法（以及
对象.hashCode
）并使用它来确定两个对象何时相等。在本例中，我们使用
=
操作符来比较两个物理对象地址。Java要求新操作符创建对象，这些对象将全部存储在JVM堆上。局部变量存储在JVM堆栈上，但它们包含对对象的引用，而不是对对象的引用对象本身

在第一种情况下，当我们检查
a==b
时，我们实际上是在检查两个引用是否指向同一位置。答案是否！

但是当a&b为50时会发生什么呢？要回答这个问题，我们应该看看下面的
Integer.valueOf
方法

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

公共静态整数值（int i）{
如果（i>=-128&&i这个问题的答案在Java编程语言指定的理解范围内

a==b
结果的变化是因为-128到127之间的任何整数都被
integer
类缓存。当创建此范围内的
int
时，将从
IntegerCache
检索，而不是创建新的integer对象

这是一个bug吗？当然不是！

Java类Integer也称为包装器类，因为它提供了一个包装
int
基元数据类型的对象。在Java中，比较两个值对象不是直接的。我们应该重写
对象.equal
方法（以及
对象.hashCode
）并使用它来确定两个对象何时相等。在本例中，我们使用
=
操作符来比较两个物理对象地址。Java要求新操作符创建对象，这些对象将全部存储在JVM堆上。局部变量存储在JVM堆栈上，但它们包含对对象的引用，而不是对对象的引用对象本身

在第一种情况下，当我们检查
a==b
时，我们实际上是在检查两个引用是否指向同一位置。答案是否！

但是当a&b为50时会发生什么呢？要回答这个问题，我们应该看看下面的
Integer.valueOf
方法

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

公共静态整数值（int i）{
如果（i>=-128&&i这个问题的答案在Java编程语言指定的理解范围内

a==b
结果的变化是因为-128到127之间的任何整数都被
integer
类缓存。当创建此范围内的
int
时，将从
IntegerCache
检索，而不是创建新的integer对象

这是一个bug吗？当然不是！

Java类Integer也称为包装器类，因为它提供了一个包装
int
基元数据类型的对象。在Java中，比较两个值对象不是直接的。我们应该重写
对象.equal
方法（以及
对象.hashCode
）并使用它来确定两个对象何时相等