Java基本类型、包装类型、缓存池

1、基本类型

类型	大小（bit）	值范围
数值型
byte	8	-128~127
short	16	-32768~32767
int	32	-2147483648~2147483647
long	64	-9223372036854774808~9223372036854774807
浮点型
float	32	3.402823e+38 ~ 1.401298e-45
double	64	1.797693e+308~ 4.9000000e-324
字符型
char	16	\u0000~\uFFFF（unicode编码）
布尔型
boolean	~	true/false

注：
1、boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定
2、JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false
3、JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的

2、包装类型

基本数据类型和包装类的对应关系
基本类型	包装类型
数值
byte	Byte
short	Short
int	Integer
long	Long
浮点
float	Float
double	Double
字符
char	Character
布尔
boolean	Boolean

注：基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成

Integer x = 1;     // 装箱 调用了 Integer.valueOf(1)
int y = x;         // 拆箱 调用了 X.intValue()

3、缓存池

问：new Integer(1) 与 Integer.valueOf(1) 的区别？

//测试程序：
public class Test {
    public static void main(String[] args) {
        Integer a1 = new Integer(1);
        Integer a2 = new Integer(1);

        Integer b1 = Integer.valueOf(1);
        Integer b2 = Integer.valueOf(1);

        System.out.println("a1 == a2 : "+(a1==a2));//false
        System.out.println("b1 == b2 : "+(b1==b2));//true
    }
}

//运行结果：
a1 == a2 : false
b1 == b2 : true

解：
1、new Integer(1) 每次都会新建一个对象；
2、Integer.valueOf(1) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。

valueOf()方法：

//valueOf() 方法的实现比较简单，就是先判断值的大小是否在缓存池范围内，如果在的话就直接返回缓存池的内容
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
    	//如果不在缓存池范围，则直接新建一个对象返回
        return new Integer(i);
    }

Integer缓存池范围（-128~127）：

		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;
        }

注：
1、编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。
2、在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 - 128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax=
来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后
IntegerCache 初始化的时候就会读取该系统属性来决定上界。

好图推荐