Autoboxing is rather scary. While I fully understand the difference between == and .equals I can't but help have the follow bug the hell out of me:
自动装箱是相当可怕的。当我完全理解==和.equals之间的区别时，我不得不从我的身上找出如下的错误:
final List<Integer> foo = Arrays.asList(1, 1000);
final List<Integer> bar = Arrays.asList(1, 1000);
System.out.println(foo.get(0) == bar.get(0));
System.out.println(foo.get(1) == bar.get(1));
That prints
,打印
true
false
Why did they do it this way? It something to do with cached Integers, but if that is the case why don't they just cache all Integers used by the program? Or why doesn't the JVM always auto unbox to primitive?
他们为什么这么做?这与缓存的整数有关，但如果是这样，为什么不缓存程序使用的所有整数呢?或者，为什么JVM不总是自动打开到原语?
Printing false false or true true would have been way better.
打印false或true会更好。
EDIT
编辑
I disagree about breakage of old code. By having foo.get(0) == bar.get(0) return true you already broke the code.
我不同意破坏旧代码。得到(0)== =(0)返回true，你已经破坏了代码。
Can't this be solved at the compiler level by replacing Integer with int in byte code (as long as it is never assigned null)
难道不能在编译器级别上通过用字节代码中的int替换整数来解决这个问题吗(只要它没有被赋为null) ?
6 个解决方案
#1
9
- Why did they do it this way?
- 他们为什么这样做?
Every Integer between -128 and 127 is cached by java. They did this, supposedly, for the performance benefit. Even if they wanted to go back on this decision now, it's unlikely that they would. If anyone built code depending on this, their code would break when it was taken out. For hobby coding, this perhaps doesn't matter, but for enterprise code, people get upset and lawsuits happen.
java缓存了-128和127之间的每个整数。他们这么做，据说是为了提高性能。即使他们现在想回到这个决定上，也不太可能。如果有人根据这个代码构建代码，那么当它被取出时，代码就会中断。对于爱好编码来说，这也许并不重要，但是对于企业代码来说，人们会感到不安，并且会发生诉讼。
- Why don't they just cache all Integers used by the program?
- 为什么不缓存程序使用的所有整数呢?
All Integers cannot be cached, because the memory implications would be enormous.
不能缓存所有的整数，因为内存的影响是巨大的。
- Why doesn't the JVM always auto unbox to primitive?
- 为什么JVM不总是自动打开到原语?
Because the JVM cannot know what you wanted. Also, this change could easily break legacy code not built to handle this case.
因为JVM不知道您想要什么。此外，这种更改很容易破坏为处理这种情况而构建的遗留代码。
If the JVM to automatically unboxed to primitives on calls to ==, this issue will actually become MORE confusing. Now you need to remember that == always compares object references, unless the Objects can be unboxed. This would cause yet more weird confusing cases just like the one you stated above.
如果JVM在调用==时自动对原语进行解析，那么这个问题将变得更加混乱。现在，您需要记住==总是比较对象引用，除非对象可以被解锁。这将导致更奇怪的令人困惑的情况，就像你上面说的那样。
Rather then worry too hard about this, just remember this rule instead:
不要太担心这个问题，只要记住这条规则:
NEVER compare objects with == unless you intend to be comparing them by their references. If you do that, I can't think of a scenario in which you'd run into an issue.
不要用== =来比较对象，除非您想通过它们的引用来比较它们。如果你这么做，我想不出你会遇到什么问题。
#2
7
Can you imagine how bad performance would be if every Integer carried overhead for internment? Also does not work for new Integer.
你能想象如果每个整数都携带用于拘留的开销，性能会有多糟糕吗?也不能用于新整数。
The Java language (not a JVM issue) cannot always auto unbox because code designed for pre-1.5 Java should still work.
Java语言(不是JVM问题)不能总是自动开箱，因为为1.5之前的Java设计的代码仍然可以工作。
#3
5
Integers in the byte range are the same object, because they are cached. Integers outside the byte range are not. If all integers were to be cached, imagine the memory required.
字节范围内的整数是相同的对象，因为它们被缓存。字节范围之外的整数不是。如果要缓存所有整数，请想象所需的内存。
And from here
从这里,
The result of all this magic is that you can largely ignore the distinction between int and Integer, with a few caveats. An Integer expression can have a null value. If your program tries to autounbox null, it will throw a NullPointerException. The == operator performs reference identity comparisons on Integer expressions and value equality comparisons on int expressions. Finally, there are performance costs associated with boxing and unboxing, even if it is done automatically
所有这些神奇之处的结果是，您可以忽略int和Integer之间的区别，并附带一些注意事项。一个整数表达式可以有一个空值。如果程序试图使用autounbox null，它将抛出NullPointerException。=运算符对整数表达式执行引用标识比较，对int表达式执行值相等比较。最后，与装箱和拆箱相关的性能成本，即使它是自动完成的
#4
4
If you skip autoboxing completely, you still get this behaviour.
如果您完全跳过自动装箱，您仍然会得到这种行为。
final List<Integer> foo =
Arrays.asList(Integer.valueOf( 1 ), Integer.valueOf( 1000 ));
final List<Integer> bar =
Arrays.asList(Integer.valueOf( 1 ), Integer.valueOf( 1000 ));
System.out.println(foo.get(0) == bar.get(0)); // true
System.out.println(foo.get(1) == bar.get(1)); // false
Be more explicit if you want a specific behavior:
如果你想要明确的行为:
final List<Integer> foo =
Arrays.asList( new Integer( 1 ), new Integer( 1000 ));
final List<Integer> bar =
Arrays.asList( new Integer( 1 ), new Integer( 1000 ));
System.out.println(foo.get(0) == bar.get(0)); // false
System.out.println(foo.get(1) == bar.get(1)); // false
This is a reason, why Eclipse has autoboxing as a warning by default.
这就是Eclipse将自动装箱作为默认警告的原因。
#5
3
A lot of people have problems with this issue, even people that write books about Java.
很多人在这个问题上都有问题，即使是写Java书籍的人。
In Pro Java Programming, mere inches below were the author talks about issues with using auto-boxed Integers as a key in an IdentityHashMap, he uses auto-boxed Integer keys in a WeakHashMap. The example values he uses are greater than 128, so his garbage collection call succeeds. If someone were to use his example and use values smaller than 128 though, his example would fail (due to the key being perma-cached).
在专业Java编程中，作者在下面几英寸的地方谈到了在IdentityHashMap中使用自动装箱整数作为键的问题，在WeakHashMap中使用自动装箱整数键。他使用的示例值大于128，因此他的垃圾收集调用成功。如果有人使用他的示例并使用小于128的值，那么他的示例就会失败(因为关键的是perma-cached)。
#6
2
When you write
当你写
foo.get(0)
the compiler does not matter how you created the List. It only looks at the compile-time type of the List foo. So, if that is a List<Integer>, it will treat that as a List<Integer>, as it is supposed to do, and a List<Integer>'s get() always returns an Integer. If you want to use the == then you have to write
编译器不关心如何创建列表。它只查看列表foo的编译时类型。因此，如果这是一个列表
System.out.println(foo.get(0).intValue() == bar.get(0).intValue());
not
不
System.out.println(foo.get(0) == bar.get(0));
because that has a totally different meaning.
因为那有完全不同的含义。
#1
9
- Why did they do it this way?
- 他们为什么这样做?
Every Integer between -128 and 127 is cached by java. They did this, supposedly, for the performance benefit. Even if they wanted to go back on this decision now, it's unlikely that they would. If anyone built code depending on this, their code would break when it was taken out. For hobby coding, this perhaps doesn't matter, but for enterprise code, people get upset and lawsuits happen.
java缓存了-128和127之间的每个整数。他们这么做，据说是为了提高性能。即使他们现在想回到这个决定上，也不太可能。如果有人根据这个代码构建代码，那么当它被取出时，代码就会中断。对于爱好编码来说，这也许并不重要，但是对于企业代码来说，人们会感到不安，并且会发生诉讼。
- Why don't they just cache all Integers used by the program?
- 为什么不缓存程序使用的所有整数呢?
All Integers cannot be cached, because the memory implications would be enormous.
不能缓存所有的整数，因为内存的影响是巨大的。
- Why doesn't the JVM always auto unbox to primitive?
- 为什么JVM不总是自动打开到原语?
Because the JVM cannot know what you wanted. Also, this change could easily break legacy code not built to handle this case.
因为JVM不知道您想要什么。此外，这种更改很容易破坏为处理这种情况而构建的遗留代码。
If the JVM to automatically unboxed to primitives on calls to ==, this issue will actually become MORE confusing. Now you need to remember that == always compares object references, unless the Objects can be unboxed. This would cause yet more weird confusing cases just like the one you stated above.
如果JVM在调用==时自动对原语进行解析，那么这个问题将变得更加混乱。现在，您需要记住==总是比较对象引用，除非对象可以被解锁。这将导致更奇怪的令人困惑的情况，就像你上面说的那样。
Rather then worry too hard about this, just remember this rule instead:
不要太担心这个问题，只要记住这条规则:
NEVER compare objects with == unless you intend to be comparing them by their references. If you do that, I can't think of a scenario in which you'd run into an issue.
不要用== =来比较对象，除非您想通过它们的引用来比较它们。如果你这么做，我想不出你会遇到什么问题。
#2
7
Can you imagine how bad performance would be if every Integer carried overhead for internment? Also does not work for new Integer.
你能想象如果每个整数都携带用于拘留的开销，性能会有多糟糕吗?也不能用于新整数。
The Java language (not a JVM issue) cannot always auto unbox because code designed for pre-1.5 Java should still work.
Java语言(不是JVM问题)不能总是自动开箱，因为为1.5之前的Java设计的代码仍然可以工作。
#3
5
Integers in the byte range are the same object, because they are cached. Integers outside the byte range are not. If all integers were to be cached, imagine the memory required.
字节范围内的整数是相同的对象，因为它们被缓存。字节范围之外的整数不是。如果要缓存所有整数，请想象所需的内存。
And from here
从这里,
The result of all this magic is that you can largely ignore the distinction between int and Integer, with a few caveats. An Integer expression can have a null value. If your program tries to autounbox null, it will throw a NullPointerException. The == operator performs reference identity comparisons on Integer expressions and value equality comparisons on int expressions. Finally, there are performance costs associated with boxing and unboxing, even if it is done automatically
所有这些神奇之处的结果是，您可以忽略int和Integer之间的区别，并附带一些注意事项。一个整数表达式可以有一个空值。如果程序试图使用autounbox null，它将抛出NullPointerException。=运算符对整数表达式执行引用标识比较，对int表达式执行值相等比较。最后，与装箱和拆箱相关的性能成本，即使它是自动完成的
#4
4
If you skip autoboxing completely, you still get this behaviour.
如果您完全跳过自动装箱，您仍然会得到这种行为。
final List<Integer> foo =
Arrays.asList(Integer.valueOf( 1 ), Integer.valueOf( 1000 ));
final List<Integer> bar =
Arrays.asList(Integer.valueOf( 1 ), Integer.valueOf( 1000 ));
System.out.println(foo.get(0) == bar.get(0)); // true
System.out.println(foo.get(1) == bar.get(1)); // false
Be more explicit if you want a specific behavior:
如果你想要明确的行为:
final List<Integer> foo =
Arrays.asList( new Integer( 1 ), new Integer( 1000 ));
final List<Integer> bar =
Arrays.asList( new Integer( 1 ), new Integer( 1000 ));
System.out.println(foo.get(0) == bar.get(0)); // false
System.out.println(foo.get(1) == bar.get(1)); // false
This is a reason, why Eclipse has autoboxing as a warning by default.
这就是Eclipse将自动装箱作为默认警告的原因。
#5
3
A lot of people have problems with this issue, even people that write books about Java.
很多人在这个问题上都有问题，即使是写Java书籍的人。
In Pro Java Programming, mere inches below were the author talks about issues with using auto-boxed Integers as a key in an IdentityHashMap, he uses auto-boxed Integer keys in a WeakHashMap. The example values he uses are greater than 128, so his garbage collection call succeeds. If someone were to use his example and use values smaller than 128 though, his example would fail (due to the key being perma-cached).
在专业Java编程中，作者在下面几英寸的地方谈到了在IdentityHashMap中使用自动装箱整数作为键的问题，在WeakHashMap中使用自动装箱整数键。他使用的示例值大于128，因此他的垃圾收集调用成功。如果有人使用他的示例并使用小于128的值，那么他的示例就会失败(因为关键的是perma-cached)。
#6
2
When you write
当你写
foo.get(0)
the compiler does not matter how you created the List. It only looks at the compile-time type of the List foo. So, if that is a List<Integer>, it will treat that as a List<Integer>, as it is supposed to do, and a List<Integer>'s get() always returns an Integer. If you want to use the == then you have to write
编译器不关心如何创建列表。它只查看列表foo的编译时类型。因此，如果这是一个列表
System.out.println(foo.get(0).intValue() == bar.get(0).intValue());
not
不
System.out.println(foo.get(0) == bar.get(0));
because that has a totally different meaning.
因为那有完全不同的含义。