为什么 == 与 Integer.valueOf(String) 的比较对 127 和 128 给出不同的结果?

2022-01-14 00:00:00 integer comparison java

我不知道为什么这些代码行返回不同的值:

I have no idea why these lines of code return different values:

System.out.println(Integer.valueOf("127")==Integer.valueOf("127"));
System.out.println(Integer.valueOf("128")==Integer.valueOf("128"));
System.out.println(Integer.parseInt("128")==Integer.valueOf("128"));

输出是:

true
false
true

为什么第一个返回true，第二个返回false?127 和 128 之间有什么我不知道的不同之处吗?(当然我知道127 < 128.)

Why does the first one return true and the second one return false? Is there something different that I don't know between 127 and 128? (Of course I know that 127 < 128.)

还有，为什么第三个返回true?

Also, why does the third one return true?

我已阅读这个问题的答案，但我还是没搞懂怎么返回true，为什么第二行的代码返回false.

I have read the answer of this question, but I still didn't get how it can return true, and why the code in second line returns false.

推荐答案

这里有一个显着的区别.

There's a striking difference here.

valueOf 正在返回一个 Integer 对象，该对象的值可能缓存在 -128 和 127 之间.这就是第一个值返回 true - 它已缓存 - 第二个值返回 false - 128 不是缓存值，因此您将获得两个单独的 Integer 实例.

valueOf is returning an Integer object, which may have its values cached between -128 and 127. This is why the first value returns true - it's cached - and the second value returns false - 128 isn't a cached value, so you're getting two separate Integer instances.

请务必注意，您将引用与 Integer#valueOf 进行比较，如果您比较的值大于缓存支持的值，它将not 评估为 true，即使解析的值是等价的(例如:Integer.valueOf(128) == Integer.valueOf(128)).您必须改用 equals().

It is important to note that you are comparing references with Integer#valueOf, and if you are comparing a value that is larger than what the cache supports, it will not evaluate to true, even if the parsed values are equivalent (case in point: Integer.valueOf(128) == Integer.valueOf(128)). You must use equals() instead.

parseInt 正在返回一个原始 int.这就是为什么第三个值返回 true - 128 == 128 被评估，当然是 true.

parseInt is returning a primitive int. This is why the third value returns true - 128 == 128 is evaluated, and is of course, true.

现在，恰好使第三个结果 true:

Now, a fair bit happens to make that third result true:

  • 一个拆箱转换发生在 您正在使用的等价运算符和您拥有的数据类型 - 即 int 和 Integer.当然，您会从右侧的 valueOf 获得一个 Integer.

  • An unboxing conversion occurs with respect to the equivalence operator you're using and the datatypes you have - namely, int and Integer. You're getting an Integer from valueOf on the right hand side, of course.

转换后，您将比较两个原始 int 值.比较会按照您对原语的预期进行，因此您最终会比较 128 和 128.

After the conversion, you're comparing two primitive int values. Comparison happens just as you would expect it to with respect to primitives, so you wind up comparing 128 and 128.

相关文章