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());
