Best practice on when to use the wrapper class and primitive type in Java
Best practice on when to use the wrapper class and primitive type in Java
Best practice on when to use the wrapper class and primitive type in Java
四个概念：
- primitive type：原始类型
- wrapper class：包装类型
- autoboxing：自动包装
- unboxing：解包
对应关系：
Primitive type | Wrapper class |
|---|---|
boolean | Boolean |
byte | Byte |
char | Character |
float | Float |
int | Integer |
long | Long |
short | Short |
double | Double |
在 Effective Java 的第五项中, Joshua Bloch 有这样的观点：
The lesson is clear: prefer primitives to boxed primitives, and watch out for unintentional autoboxing.
意思就是：相对于 boxed primitive 更喜欢 primitive，并且需要注意无意识的 autoboxing 机制。
类的一个很好的用途是作为泛型类型（包括Collection类，比如list和map），或者当你想要将它们转化为其他类型而不进行隐式转换时（例如 Intege类具有方法 doubleValue() or byteValue()）。
因此，最佳实践是能使用primitive的都用primitive，除非你正在处理泛型（确保你知道 autoboxing 和 unboxing）
使用 primitive
在以下几种情况下使用 primitive
primitive 性能更好
//隐式的降低程序速度
public static void main(String[] args) {
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
sum += i;
}
System.out.println(sum);
}这个程序虽然能得到正确 sum ，但是效率比理论中会慢很多。变量 sum 被定义成了Long而不是 long ，这就意味着程序构建了 2^31 次没必要的 Long 实例（每次 long i 被加到 Long sum 上时算一次）。将sum 的类型从 Long 改为 long，程序时间可以达到数量级的缩减。
primitive 可读性更高
Integer a = 2;
Integer b = 2;
if (!a.equals(b)) {
// ...
}
int c = 2;
int d = 2;
if (c != d) {
// ...
}代码中的两种相等比较，多数人都会认为第二种更易读，对于先上手 C++ / Python 的人更是这样。
使用 primitive 可以避免一些错误
如果不了解 wrapper class 中的一些机制，会遇到一些莫名其妙的问题
莫名其妙的 NullPointException
Integer getValue();
...
int myValue = getValue(); // getValue返回null时就会抛出NPE这个代码可以编译通过，但是会抛出空指针异常。int b = a实际上是int b = a.intValue()，由于a的引用值为null，在空对象上调用方法就会抛出NPE。
wrapper class 的引用相等性
在Java中，== 符号判断的内存地址所对应的值的相等性，具体来说，基本类型判断值是否相等，引用类型判断其指向的地址是否相等。
Integer a1 = 1;
Integer a2 = 1;
System.out.println(a1 == a2); // true
Integer b1 = 222;
Integer b2 = 222;
System.out.println(b1 == b2); // false这两段代码的结果是不同的，具体需要看下 java.lang.Integer 的 valueOf 方法的源码：
package java.lang;
import java.lang.annotation.Native;
public final class Integer extends Number implements Comparable<Integer> {
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;
}valueOf 方法会缓存 -128 到 127 之间的值，因此第一段代码会取到的是同一个对象，第二段代码会创建两个对象且地址不一样，因此导致的结果不同。
使用 wrapper class
使用泛型的时候必须使用 wrapper class，因为Java不支持使用基本类型作为类型参数
List<int> list; // 编译器会提示：Type argument cannot be of primitive type
List<Integer> list; // 这个就是正确的参考：