Java 基本类型及其包装类

Java 提供了8种基本类型：

byte 1个字节
short 2个字节
int 4个字节
long 8个字节
float 4个字节
double 8个字节
char 2个字节
boolean bollean在JVM是用int表示的

对应的封装类

Byte, Short, Integer, Long, Float, Double, Char, Boolean

Java 有了基本数据类型为什么还需要包装类？

Java 是一个面向对象的编程语言，基本的数据类型并不具有对象的性质，为了让基本数据类型也具有对象的特性，就出现了包装类型，他们相当于把基本数据类型“包装起来”，使得它具有对象的特性，并为其添加了属性和方法，丰富了基本类型的操作。另外当需要往集合类中，比如ArrayList, HashMap中放东西时，像int，double这类基本数据类型是放不进去的，因为容器都是装object的，这时就需要基本类型的包装类了。

基本数据类型和包装类的区别

1.存储方式不同， 基本数据类型是直接将变量存储在栈中，而包装类存储在堆中(通过new 创建对象)。

2. 初始值不同， int的初始值是0，boolean的初始值是false，而包装类的初始值是null.
3. 包装类是引用的传递，基本数据类型是值得传递。

自动装箱，拆箱

装箱：自动把基本类型转换成包装类型, 装箱调用了包装类的valueOf方法

Integer i = 20;    //自动装箱，反编译后的代码Integer i = Integer.valueOf(20)

拆箱：自动把包装类型转换成基本类型,

Integer i1 = new Integre(10);
int i2 = i1;    //自动拆箱， 反编译后的代码： int i2 = i1.intValue();

什么时候Java会自动拆装箱

1. 将基本数据类型放入集合类

        List<Integer> myList = new ArrayList<>();
        for(int i =0; i <50; i++){
            myList.add(i); // i 会自动装箱成Ingeter类型
        }

2.包装类型和基本数据类型比较

        Integer i5 = 100;
        if (i5 == 100){ // i5会自动拆箱成int 类型
            //do something
        }

3. 包装类的运算

        Integer i5 = 100;
        Integer i6 = 99;
        System.out.println(i5+i6);

4. 函数参数与返回值

//自动拆箱
public int getNum1(Integer num) {
 return num;
}
//自动装箱
public Integer getNum2(int num) {
 return num;
}

自动拆装箱与缓存

在Java 5中，在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用.
缓存的默认大小为 -128~127。缓存的最大值可以通过-XX:AutoBoxCacheMax=<size>或者java.lang.Integer.IntegerCache.high 来指定。

    /**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * jdk.internal.misc.VM class.
     */

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

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

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

缓存机制只适用于自动装箱。使用构造函数创建对象不适用。

        Integer i5 = 100;
        Integer k = new Integer(100);  //构造函数不适用缓存机制
        Integer j = Integer.valueOf(100);

        Integer i6 = 200;
        Integer m = Integer.valueOf(200);  //超出默认缓存机制大小

        System.out.println(i5==k);
        System.out.println(i5==j);
        System.out.println(i6==m);

运行结果：

false
true
false