源码之Integer

一、由Integer对象的比较引出的一系列深思

 public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 128;
        Integer i4 = 128;
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(128);

        System.out.println(i1==i2);
        System.out.println(i3==i4);
        System.out.println(i3.equals(i4));
        System.out.println(i1.equals(i5));
        System.out.println(i1==i5);
        System.out.println(i3==i6);
        System.out.println(i3.equals(i6));
    }

true
false
true
true
false
false
true

是不是很疑惑？答案和我想的也不太一样

1、首先要了解一下java的装箱和拆箱，

public class Main {
    public static void main(String[] args) {
         
        Integer i = 10;
        int n = i;
    }
}

从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

　　其他的也类似，比如Double、Character，不相信的朋友可以自己手动尝试一下。

　　因此可以用一句话总结装箱和拆箱的实现过程：

　　装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。海子的原文

//boolean原生类型自动装箱成Boolean
    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }
 
 
    //byte原生类型自动装箱成Byte
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }
 
 
    //short原生类型自动装箱成Short
    public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt + offset];
        }
        return new Short(s);
    }
 
    //char原生类型自动装箱成Character
    public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }
 
    //int原生类型自动装箱成Integer
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
 
    //long原生类型自动装箱成Long
    public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }
 
    //double原生类型自动装箱成Double
    public static Double valueOf(double d) {
        return new Double(d);
    }
 
 
    //float原生类型自动装箱成Float
    public static Float valueOf(float f) {
        return new Float(f);
    }

2、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);
    }
//low = -128
//high = 127 好像可以通过 JVM 的启动参数 -XX:AutoBoxCacheMax=size 修改
//当valueOf入参在[-128,127]时直接从IntegerCache返回一个Integer对象,其他则直接new一个
//IntegerCache就是Integer的缓存，把经常用到的对象（[-128,127]）先new出来，方便直接取

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

其他包装类也有类似的情况

基本类型	装箱类型	取值范围	是否缓存	缓存范围
boolean	Boolean	true, false	是	true, false
char	Character	u0000 ~ uffff	是	u0000 ~ u007f
long	Long	-2^63 ~ (2^63 - 1)	是	-128～127
int	Integer	-2^31 ~ (2^31 - 1)	是	-128 ~ 127
short	Short	-2^15 ~ (2^15 - 1)	是	-128 ~ 127
byte	Byte	-128 ~ 127	是	-128 ~ 127
double	Double	--	否	--
float	Float	--	否	--

 

3、Integer的equals方法

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
//Integer重写了Object的equals方法，可见它比较的是Integer的值，而非地址

4、所以开头的答案是不是明了了？

public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 128;
        Integer i4 = 128;
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(128);

        System.out.println(i1==i2);
//对象的==比较的是地址，i1、i2都在[-128,127]内，所以是直接从缓存中取得，当然就是同一个了，地址自然一样       true
        System.out.println(i3==i4);
//128不在缓存中，自己设置high的话就另说了，所以每次都是new的新的对象，所以不是同一个对象                    false
        System.out.println(i3.equals(i4));
//Integer的equals比较的是对象的value值       都是128   所以                                         true
        System.out.println(i1.equals(i5));
//i1从缓存中取得，而i5是new的新的对象  然而equals比较的值  所以                                        true
        System.out.println(i1==i5);
//i1从缓存中取得，而i5是new的新的对象   ==比较的是地址  所以                                           false
        System.out.println(i3==i6);
//i3和i6都是new的新的对象                                                                         false
        System.out.println(i3.equals(i6));
//比较值  都是128                                                                                 true
    }

5、为什么要引入包装类？

1)java是面向对象的语言，所以要为基本数据类型提供包装类，方便调用对象的一些方法

2）方法泛型的使用

  ArrayList<Integer> list = new ArrayList<>();//正确
  ArrayList<int> list1 = new ArrayList<>();//错误