Integer与int的区别

1.典型回答

int 是基本数据类型（Primitive Types），是 java 的8个基本数据类型之一，java 中虽然号称一切都是对象，但是基本数据类型除外。

2.基本介绍

Integer 是 int 对应的包装类，有一个 int 字段 value 存储数据，并且提供了基本操作，比如数学运算，int 和字符串之间的转换，不同禁止之间的转换，。另外非常重要的一个功能就是自动装箱和自动拆箱功能（boxing/unboxing），java可以根据上下文自动进行转换。

public Integer(int value) {
    this.value = value;
}
private final int value;

3.值缓存

在了解了Integer的值缓存之前，先思考一下下面这道测试题：

  // 测试题1
public static void main(String[] args) {
    Integer a1 = 100;
    Integer a2 = 100;

    Integer b1 = 1000;
    Integer b2 = 1000;

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

Integer的缓存范围是-128到127，但是在特别的应用场景，比如我们明确知道应用会频繁使用更大的数据，这是可以利用JVM参数调整缓存上限值。

-XX:AutoBoxCacheMax=N

这些实现，在Integer源码中，实现在静态内部类IntegerCache的静态初始化块里，static修饰的变量，JVM会提前给我们初始化好，这个特性在实际开发过程中，经常用来作缓存。

在下面的源码可以看到，首先会读取 jvm 参数来确定值缓存的范围，然后将范围内的整型初始化保存到static final修饰的cache数组中，在下一节中会讲到自动装箱时会从缓存cache中获取对应的数值，避免了重复创建对象，节省了内存开销。

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

    // jvm启动类被加载时调用
    static {
        // 最大值
        int h = 127;

        // 读取配置缓存最大值，有两种配置方式
        // -Djava.lang.Integer.IntegerCache.high=255
        // XX:AutoBoxCacheMax=255
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        // 如果设置了缓存最大值
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // 缓存数组最大是Integer.MAX_VALUE, i不能过大
                // 这里不能使用 if(Integer.MAX_VALUE < i-(-low))，会溢出
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // 当配置的缓存最大值不是一个数字，则忽略.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        // 缓存对象值 [-128, h] 到 Integer 数组 cache
        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才有，同样存在于其他的一些包装类，比如：

• Boolean，缓存了true/false对应实例，确切的说，只会返回两个常量实例 Boolean.TRUE/FALSE
• Short，同样默认缓存了[-128, 127]之间的数值
• Byte，全部数值被缓存[-128, 127]
• Character，缓存范围\u0000到\u007F

Integer的常量池用到了享元模式， 主要用于减少创建对象的数量，以减少内存占用和提高性能

4.自动装箱、拆箱

自动装箱实际上算是一种语法糖。什么是语法糖，可以简单理解为Java平台为我们自动进行了一些转换，保证不同的写法在运行时等价，他们发生在编译阶段，生成的字节码是一致的。

从生成的class文件中可以看到，javac替我们自动把装箱转换为Integer.ValueOf()，把拆箱替换为Integer.intValue()。

//源代码
Integer boxing = 666;
int unboxing = boxing + 1;

//反编译
Integer boxing = Integer.valueOf(666);
int unboxing = boxing.intValue() + 1;

自动装箱调用了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);
}

Java 中字符串是不可变的，保证了基本的信息安全和并发编程中的线程安全。所有包装类中存储数值的成员变量value，都被声明为private final，所以，它们同样是不可变类型。

原则上，建议避免无意中的装箱，拆箱行为，在性能敏感的场合，创建 10w 个 Java 对象和 10W 个整型的开销可不是一个数量级的，不管是内存使用还是处理速度，仅对象头的空间占用就已经是数量级的差距了。Java对象都是引用类型，如果是一个基本类型数组，在内存里是一段连续的内存，而对象数组则不然，数据存储的是引用，对象往往分散的存储在堆的不同位置，这样的设计虽然带来了极大的灵活性，但是也导致了数据操作的低效，尤其无法充分利用现代 CPU 的缓存机制。

Integer 等包装类，定义了类似 SIZE 或者 BYTES 这样的常量，这样的设计考虑是为了保证32位和64位平台中Integer的数据位数一致，开发者无需担心数据的位数差异。

5.equals 方法

由于 IntegerCache 的存在，我们比较Integer类型的数据时会使用equals方法，是否完全搞懂了Integer的equals方法，可以先思考一下下面这道测试题：

// 测试题2
public static void main(String[] args) {
    Integer i = new Integer(3);
    Long l = new Long(5);
    
    System.out.println(i.equals(l));    //false
}

查看源码可以知道，Integer的equals方法会先判断参数 obj 是否为Integer类型，然后进行拆箱，最后比较基础类型值的大小。

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

6. == 比较

在了解了IntegerCache之后，很容易陷入一个误区，对于大于127的整型使用==判断即认为不相等。
思考一下下面这道测试题：

public static void main(String[] args) {
    int a = 200;
    Integer b = 200;
    Integer c = 200;

    System.out.println(b == a);            // true 自动拆箱
    System.out.println(b.equals(a));    // true 自动装箱
    System.out.println(b == c);            // false 不拆箱
}

在判断b==a中，很多人会有思维定势，认为会使用 IntegerCache，当大于127时会new新对象，所以结果是false。

这种想法的错误点在于使用 IntegerCache 的前提是默认装箱，而在基本类型int与包装类Integer的比较时会自动拆箱，所以b == a的结果为true；在Integer与Integer的比较时会认为是对象的比较，则不会进行拆箱，所以b == c的结果为false。
上面的代码可以javap -c Test.class反编译为

    // 反编译
    System.out.println(b.intValue() == a);
    System.out.println(b.equals(Integer.valueOf(a)));
    System.out.println(b == c);

为什么基本类型int与Integer比较时会自动拆箱而不是自动装箱呢？

参考stackoverflow 回答，JDK 选择这么做是为了与其他运算符保持一致，如a > b，a + b等运算符操作，包装类型并不支持这些操作，所以选择拆箱为基本类型进行运算。

    Integer b = 200;
    Integer c = 200;
    Integer dd = b + c;

由于 +运算符对基本类型int才生效，所以+的两个参数会拆箱为基本类型，相加后再装箱为包装类型，上面代码反编译后：

  // 反编译
 Integer dd= Integer.valueOf(b.intValue() + c.intValue());