数据类型

Java 中的数据类型有两种，基本数据类型和引用数据类型。

• 基本数据类型又称为内置类型，Java 保留了基本数据类型，主要是为满足 Java 高效率执行的需求。
• 引用数据类型又称为扩展类型，它的创建是需要去 new 一个对象，该对象的内存分配在堆区，同时栈区会保存一个指向该对象的引用。

1、基本类型

数据类型	大小（bit）	默认值	包装类型
byte	8	0	Byte
short	16	0	Short
int	32	0	Integer
long	64	0L	Long
float	32	0.0f	Float
double	64	0.0d	Double
char	16	‘\u0000’	Character
boolean	~	false	Boolean
void	~	~	Void

• 浮点型有 float 、double , 默认数据类型是 double。

• boolean 的值为：true、false，JVM会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。boolean 类型的数据可以用1 bit 来存储，但没有明确规定其大小。

• void 表示“没有东西”，如在方法返回值中，表示没有返回值；Void 为 void 的包装类，是一个占位符类，本身不起作用，不能被实例化，多用于泛型中作占位符使用。

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

  Integer a = 1;     // 装箱
  int b = a;         // 拆箱
  

2、引用类型

Java 常见的引用类型（对象类型）：类、接口、数组枚举以及字符串等。

如果要判断两个对象是否相同，则需要使用 equals() 方法，但有一点需要注意：equals() 方法的默认行为是比较引用。如果是你自己写的类，你应该为它重写 equals() 来比较对象的内容。大多数 Java 类库都实现了比较对象内容的 equals() 方法。

3、缓存池

Integer 中有个静态内部类 IntegerCache ，里面有个 cache[],也就是 Integer 常量池，常量池的大小为一个字节（-128~127）。

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

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

jdk 1.8 源码中

public static Integer valueOf(int i) {
    // 判断是否在缓存池范围中，如果在则返回缓存池中的内容，否则就new Integer() 创建一个新的对象。
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

IntegerCache 源码，从中可以知 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() {}
    }

测试代码

    Integer a = new Integer(11);
    Integer b = new Integer(11);
    System.out.println(a == b);     // false
    Integer x = Integer.valueOf(22);
    Integer y = Integer.valueOf(22);
    System.out.println(x == y);     // true
    // 编译器会在自动装箱过程调用 valueOf() 方法
    Integer n = 33;
    Integer m = 33;
    System.out.println(m == n);     // true

4、包装类的作用

• 解决在编码过程中只支持对象的情况；

List<int> list = new ArrayList<>(10);		// 编译报错
List<Integer> list = new ArrayList<>(10);	// 正确

• 充当适配器的角色，方便类型之间的转换。

	int a1 = Integer.valueOf("1");
	int a2 = new Integer("1");
	int a3 = new Integer("1").intValue();