Integer的缓存
Integer内部实现了一个缓存，会缓存-128～127之间的数字。Integer在赋值的时候会发生自动装箱操作，调用Integer的valueOf方法。
/**
* 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);
}
public class IntegerTest {
public static void main(String[] args) {
Integer a1 = 1;
Integer a2 = 1;
System.out.println("a1 equals a2: " + a1.equals(a2));
System.out.println("a1 == a2: " + (a1 == a2));
a1 = 128;
a2 = 128;
System.out.println("a1 equals a2: " + a1.equals(a2));
System.out.println("a1 == a2: " + (a1 == a2));
// 直接new的对象的就不会去关注是否有缓存
a1 = new Integer(1);
a2 = new Integer(1);
System.out.println("a1 equals a2: " + a1.equals(a2));
System.out.println("a1 == a2: " + (a1 == a2));
a1 = new Integer(128);
a2 = new Integer(128);
System.out.println("a1 equals a2: " + a1.equals(a2));
System.out.println("a1 == a2: " + (a1 == a2));
}
}
输出:
a1 equals a2: true
a1 == a2: true
a1 equals a2: true
a1 == a2: false
a1 equals a2: true
a1 == a2: false
a1 equals a2: true
a1 == a2: false
Integer的拆装箱
将基本数据类型转换成一个Integer的对象叫做装箱，将一个Integer对象转换成一个基本数据类型的过程叫做拆箱。
Integer a = 1; // 自动装箱
int a1 = new Integer(12); //自动拆箱
自动装箱调用的是Integer.valueOf(int i);
自动拆箱调用的是intValue()
大规模的自动拆装箱会导致资源的浪费，需要注意。同时还需要注意，自动拆箱的时候，如果是一个null，则很可能会出现空指针的问题。
Integer a3 = null;
int a4 = a3; // NullPoint
System.out.println(a4);
整数溢出
在java中，int类型占32位，第一位表示数字的正负号，所以int类型的范围从-2^31 ~ 2^31即-2147483648到2147483648，当两个int类型的值相加超过了最大值，就会出现溢出，当出现溢出的时候，并不会抛出异常，而是继续向前进位，所以就会出现一个负数的情况
System.out.println(Integer.MAX_VALUE + 1);// 输出-2147483648
浮点型
浮点型会存在舍入误差，尽量不要在涉及到精确到金额的时候使用。涉及到精确的数字的时候一定要使用BigDecimal
public void test() {
System.out.println(2.0-1.1); //=>0.8999999999999999
}
虽然但是误差很小，但是结果还是和你想象中的有些差别的。
