Java 基础系列

Java 基础

1. 数据类型

1.1 基本类型

type	size	range	default value
byte	8	-128 ~ 127	0
short	16	-32,768 ~ 32,767	0
int	32	-231 ~ 231-1	0
long	64	-263 ~ 263-1	0L
float	32	\	0.0F
double	64	\	0.0D
char	16	‘\u0000’(0) ~ ‘\uffff’(65,535)	‘\u0000’
boolean	?	true and false

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

1.2 包装类型

基本类型都有对应的包装类型。

Primitive type	Wrapper class
boolean	Boolean
byte	Byte
char	Character
float	Float
int	Integer
long	Long
short	Short
double	Double

基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。

Integer x = 2;  // 装箱
int y = x;  // 拆箱

1.3 缓存池

new Integer(123) 与 Integer.valueOf(123) 的区别在于：

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

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == 123);  // true
System.out.println(y == 123);  // true
System.out.println(x == y);  // false
System.out.println(x.equals(y));  // true

Integer x = Integer.valueOf(123);
Integer y = Integer.valueOf(123);
System.out.println(x == 123);  // true
System.out.println(y == 123);  // true
System.out.println(x == y);  // true
System.out.println(x.equals(y));  // true

valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。

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

在 Java 8 中，Integer 缓存池的大小默认为 -128 ~ 127。

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() {}
}

编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。

Integer m = 123;
Integer n = 123;
System.out.println(m == n);  // true

基本类型对应的缓冲池如下：

• boolean – true and false
• byte – all byte values
• short – between -128 and 127
• int – between -128 and 127
• char – in the range '\u0000' to '\u007F'

在使用这些基本类型对应的包装类型时，如果该数值范围在缓冲池范围内，就可以直接使用缓冲池中的对象。

在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 -128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax=<size> 来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。