包装类是什么（Integer和int的区别）

引言

今天在学习群里看到有人问了一个问题，发现涉及到基本数据类型与包装类等知识，发现自己掌握的并不好，查了下相关资料，借此记录下

public static void main(String[] args) {
    Integer i = 100;
    Integer i1 = 100;
    Integer j = 200;
    Integer j1 = 200; 
    System.out.println(i==i1); //true
    System.out.println(j==j1); //false
}

如果你发现这个问题你也有点不清楚，希望这篇文章能给你解惑

什么是包装类

我们知道在Java中有8种基本的数据类型，比较常用的有int, boolean, float, char等，但是这些数据类型不是对象，无法调用Object中所存在的方法，这时候就会存在诸多的困难，就比如说我们想把int类型的数字转化为字符串，我们知道Object中有toString()的方法，但是int如果不是对象，那么我们要怎么能使用方法呢。

因此Java就将基本数据类型以及相对应的方法包装到一个类中，这时候这个类就称之为包装类，这些类分为两种。

一种是对象型包装类，并不继承其他类。这种数据类型的特点是都是独特的，没有与其类似的数据类型

//boolean 类型的包装类
public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>

//char类型的包装类
public final class Character implements java.io.Serializable, 
                                        Comparable<Character> 

还有一种是继承Number类，这些数据类型都是数字型的。

// byte的包装类
public final class Byte extends Number implements Comparable<Byte>

// short的包装类
public final class Short extends Number implements Comparable<Short> 

// int的包装类
public final class Integer extends Number implements Comparable<Integer>

// long的包装类
public final class Long extends Number implements Comparable<Long> 

// float的包装类
public final class Float extends Number implements Comparable<Float> 

// double的包装类
public final class Double extends Number implements Comparable<Double> 

自动装箱与自动拆箱

自动装箱

通过阅读java文档，里面有个这样的例子

    List<Integer> li = new ArrayList<>();
    for (int i = 1; i < 50; i += 2)
        li.add(i);

这样的编译并不会错误，尽管我们往Integer类型的列表中添加了int类型的数字，这是因为Java为我们提供了自动装箱的功能，其中li.add(i) == li.add(Integer.valueOf(i))，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类型的数字，因此编译并不会报错。（方法的具体内容后面有介绍）
这就是自动装箱的过程：

• 作为参数传递给需要相应包装类对象的方法。
• 分配给相应包装器类的变量。

自动拆箱

在Java文档中同样有这样一个例子

public static int sumEven(List<Integer> li) {
    int sum = 0;
    for (Integer i: li)
        if (i % 2 == 0)
            sum += i;
        return sum;
}

虽然Integer对象进行了取余和加法，但是编译器同样不会报错，因为这时的i相当于i.intValue

public int intValue() {
        return value;
    }

返回的是一个int类型的数字，这就是自动拆箱的过程：

• 作为参数传递给需要对应基本数据类型值的方法
• 赋值给相应基本数据类型的变量。

Integer包装类中的缓存池

既然了解了什么是包装类，那么回到上面的问题，为什么第一个返回的是true而第二个返回的是false呢

Integer包装类中有一个IntegerCache类

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

这个类的作用在于规定了一个最小值low=128，而最大值high一般默认为127，但是这个上界是可调的，在启动jvm的时候，通过 -XX:AutoBoxCacheMax=<size> 来指定这个缓冲池的大小，该选项在JVM初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。IntegerCache类最后创建了一个Integer类型的数组cache，然后将[-128, 127]的值都传进这个数组中。

在这个类的下面有个方法

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

这个方法说明如果输入的int值在[-128, 127]中，则直接会从上面类的缓存数组直接取出，否则则会重新创建一个Integer实例。
而在编译中Integer j = 200, 会被编译成

Integer j = Integer.valueOf(200);

而200并不在[-128, 127]的范围内，因此就会创建一个对象，这时候对象的内存地址就会不同，因此会返回false值。

进一步实验

    int k = 200;
    Integer k1 = 200;
    Integer k2 = new Integer(200);
    System.out.println(k == k1);//true
    System.out.println(k == i2);//true
    System.out.println(k2 == k3);//false

在Integer的值与k值比较时，Integer的类型的值都会进行自动拆箱，也就是使用intValue的方法使得Integer类型转化为int的基本数据类型，因此两次比较都会为true。而k1，k2的值都是新创建的Integer对象，内存地址不同，因此为false。

如果有什么不对的地方，欢迎大家指出，大家一起进步

参考文章：

1. Java 包装类是什么
2. Autoboxing and Unboxing
3. Integer与int的种种比较你知道多少？