Java基本数据类型及对应封装类详细解读

1、Java八种基本数据类型的大小、默认值及对应封装类

基本类型	大小（字节）	默认值	取值范围	封装类
byte	1	(byte)0	-128～127	Byte
short	2	(short)0	-32768～32767	Short
int	4	0	-231 ～ 2(31-1)	Integer
long	8	0L	-263 ~ 2(63-1)	Long
float	4	0.0f	1.4E-45~3.4028235E38	Float
double	8	0.0d	4.9E-324~1.7976931348623157E308	Double
boolean	-	false	true或false	Boolean
char	2	\u0000(null)	0～65535	Character

2、基础类型与包装类型的区别

• 包装类型可以为null，基础类型不可以。

        例如：int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个对象，再任何引用使用前，必须为其指定一个对象，否则会报NullPointer。

        包装类型的这一特性使其广泛应用于POJO中（POJO专指只有setter/getter/toString的简单类，例如DO/DTO/BO/VO 等），而基本类型不行。因为数据库的查询结果可能是null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把Integer 对象转换成int值），就会抛出 NullPointerException 的异常。

具体示例如下代码，将为null的Interger类型a，赋值给int类型b，编译报 NullPointerException 。

public class Main {
    public static void main(String[] args) {

        Integer a = null;
        int b = a;
        System.out.println(b);

    }
}

 执行结果：

• 包装类型是对象，基本类型不是。

        在Java中可以理解为一切皆对象，但是基本类型除外，因为基本数据类型是Java语言的一部分，它们是原始的、简单的数据类型，直接存储在内存中的栈中，不需要进行对象的创建和销毁，所以基本类型不是对象。

• 内存中存储方式及位置的不同

        基本数据类型直接存储在内存中的栈中，在声明时系统会自动给它分配空间，而包装类型声明时只是分配了引用空间，需要通过引用指向实例，必须通过实例化开辟数据空间之后才可以赋值，具体的实例保存在堆中。

        因此基本数据类型在内存分配和访问上更加高效，可以提高程序的执行效率。而包装类型的效率相对就明显更低。

示例如下：Long与long做+=操作耗时比较，两者完全不在一个数量级，当然这是针对数据量较大的情况，正常情况下时间差异还是没有这么大的。

public class Main {
    public static void main(String[] args) {

        //包装类型
        long t1 = System.currentTimeMillis();
        Long sum1 = 0L;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            sum1 += i;
        }
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);

        //基本类型
        long t3 = System.currentTimeMillis();
        long sum2 = 0L;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            sum2 += i;
        }
        long t4 = System.currentTimeMillis();
        System.out.println(t4-t3);

    }
}

执行结果：

 

• 包装类型可以用于泛型，基本类型不可以

        泛型的使用只能是对象，所以基本数据类型不可以用于泛型。最常见的例如集合中使用从而限定集合中数据元素的类型。

示例如下：语法报错，List泛型，参数类型不能为基本类型。

public class Main {
    public static void main(String[] args) {

        List<int> l1 = new ArrayList<>();//Syntax error, insert "Dimensions" to complete ReferenceType
        List<Integer> l2 = new ArrayList<>();

    }
}

 3、自动装箱与拆箱

装箱就是自动将基本数据类型转换为包装类型；如int —>Integer的转换，实际就是调用Integer的valueOf(int)方法，将int转换为Integer。

拆箱就是自动将包装类型转换为基本数据类型；如Integer—>int的转换，实际就是调用Integer的intValue()方法，将Integer转换为int。

装箱与拆箱是Java SE5中引入的概念，在Java SE5之前，如果要创建一个数值为1的Integer对象：

Integer i = new Integer(1);

而在Java SE5之后，只需：

Integer i = 1;//自动装箱实现

4、Integer缓存池

Java SE5在引入装箱与拆箱概念的同时，还引入了一个叫IntegerCache的Integer缓存池（常量池）的特性，有助于Integer使用时节省内存、提高性能。

先看一段经典案例代码

public class IntegerCacheExample {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.printf("a==b: %s.\n", a == b);
        Integer c = 128;
        Integer d = 128;
        System.out.printf("c==d: %s.\n", c == d);
    }
}

输出结果：

是什么问题导致的这种情况呢？是在自动装箱过程中调用的valueOf(int)方法，使用了Integer缓存池的特性导致的。

看一下valueOf的具体实现：

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

看到int在一定取值范围内，没有直接实例化一个Integer对象，而是使用了IntegerCache中的常量池cache[]。

继续看IntegerCache的源码：

    /**
     * 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
     * sun.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 =
                sun.misc.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() {}
    }

在源码中可以看到，默认在-128到127之间的int，转换成Integer时，使用的是常量池的中对象。

所以在示例代码中的a和b实际上都是常量池中的同一个Integer对象，==判断的两侧对象地址相等，返回ture；而c和d因为超出了常量池默认取值范围，所以是分别示例化了一个新的Integer对象，==判断的对象地址不相等，返回false。

回到IntegerCache源码，在源码注释中提到了常量池生成的默认范围是-128~127，但是可以在启动之前配置JVM参数AutoBoxCacheMax进行常量池范围修改。