Java基本类型及其封装类

Java设定了每种基本类型所占存储空间的大小，并且不随机器结构的变化而变化。

主类型	大小	封装类型
byte	8位	Byte
short	16位	Short
int	32位	Integer
long	64位	Long
float	32位	Float
double	64位	Double
char	16位	Char
boolean	–	Boolean

注：1.　boolean变量仅定义为 true 或 false，具体大小没有明确指定
　　2.　小数默认为double类型，浮点型数据需后加 f
　　3.　整数默认为int类型，长整型需后加 L
　　4.　JDK5.0后提供自动拆装箱机制，基本数据类型和包装类型能够自动转换
　　5.　Java提供两个用于高精度计算的类：BigInteger（任意精读的整数）和BigDecimal（任意精读的定点数 ），提供的方法和基本类型（int或float方法）类似，只不过必须以方法调用取代运算符方式来实现，

基本类型与其包装类的区别
　· 基本类型只包含数据，而包装类包含了数据和操作
　· 在一个方法中，基本类型变量和引用变量都在栈中，而具体的对象存储在堆中
　· 引用变量缺省值为 null，基本类型缺省值与它们的类型有关
　· == 用于基本类型比较数值是否相等，用于对象比较对象的引用是否相等

为了节约内存，Java对除了Folat和Double的其他六种包装类实现了常量池，但是只在 [-128，127] 这个范围内使用常量池
以Integer为例

    public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = new Integer(127);
        System.out.println(i1 == i2);// 输出true
        System.out.println(i1 == i3);// 不同的引用，输出false
        i1 = 128;
        i2 = 128;
        System.out.println(i1 == i2);// 输出false
    }

分析：当我们直接给Integer赋值，默认会调用Integer的valueOf(int i)方法，分析源码：
IntegerCache.high >= 127，这是肯定的，当 i 的值大于127时，会创建新的对象，小于127回去IntegerCache缓存数组中去拿。

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

内部类IntegerCache实现如下：

    private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

由此可见这个静态的 cache 缓存了数值在 [-128,127] 范围的Integer对象。

        Integer i1 = 40;
        Integer i2 = 40;
        Integer i3 = 0;
        Integer i4 = new Integer(40);
        Integer i5 = new Integer(40);
        Integer i6 = new Integer(0);

        System.out.println("i1=i2   " + (i1 == i2)); // 输出true
        System.out.println("i1=i2+i3   " + (i1 == i2 + i3)); // 输出true
        System.out.println("i1=i4   " + (i1 == i4)); // 输出false
        System.out.println("i4=i5   " + (i4 == i5)); // 输出false
        System.out.println("i4=i5+i6   " + (i4 == i5 + i6)); // 输出true 
        System.out.println("40=i5+i6   " + (40 == i5 + i6)); // 输出true      

解释：语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。
推荐：
Java常量池理解与总结