一道有意思的笔试题

今天在做某家公司的笔试题时，做到了一个有意思的题。

---

输出以下程序的结果：

public static void main(String[] args){
Integer i1=127,i2=127,i3=128,i4=128;
System.out.println(i1==i2);
System.out.println(i1.equals(i2));
System.out.println(i3==i4);
System.out.println(i3.equals(i4));
}

乍一看，只有啥好做的？
Integer作为包装类型，这四个变量不就是每个new一个吗？
所以，”==”比较的是两个引用的指向的对象的地址，而”equals()”则是比较两者的值。所以，结果很容易就出来了。
false true false true;?

---

结果证明我确实想错了，看似简单的笔试题，背后考察的是基本类型与包装类型的装箱及拆箱过程。

下面是java中的自动装箱及拆箱机制以及缓冲池。

基本数据类型的使用量是很大的，java常量池，在节省内存方面是一个很好的机制，相同的数据，在常量池中只要保留一份即可

Java的8种基本类型(Byte, Short, Integer, Long, Character, Boolean, Float, Double), 除Float和Double以外, 其它六种都实现了常量池, 但是它们只在大于等于-128并且小于等于127时才使用常量池。

以 Integer 进行举例，在其生成新对象时源码调用如下：
Integer a = 3; 这是自动装箱
其实编译器调用的是 static Integer valueOf(int i)这个方法
查阅源码知道,valueOf(int i)返回一个表示指定的 int 值的 Integer 对象。

public static Integer valueOf(int i)    
{     
    if(i >= -128 && i <= IntegerCache.high)   
    {   

        return IntegerCache.cache[i + 128];     
    }       
    else   
    {   
        return new Integer(i);    
    }       
}   

其中的IntegerCache就是实现基本数据类型的缓存关键

private static class IntegerCache   //定义类名   
{     
    static final int high;     
    static final Integer cache[];   //cache缓存是一个存放Integer类型的数组   

    static  //初始化   
    {     
        final int low = -128;       //最小值是固定的   
        int h = 127;                //最大值暂时是127   
        if (integerCacheHighPropValue != null)
        {     
            int i = Long.decode(integerCacheHighPropValue).intValue();     
            i     = Math.max(i, 127);     
            h     = Math.min(i, Integer.MAX_VALUE - -low);     
        }     
        high = h;  //此时high就是127   

        cache = new Integer[(high - low) + 1];  //有256个元素   
        int j = low;                            //j的初始值是-128   
        for(int k = 0; k < cache.length; k++)   //缓存区间数据      
            cache[k] = new Integer(j++);        //将-128~127包装成256个对象存入缓存   
    }     
    private IntegerCache(){}  //构造方法,不需要构造什么   
}  

其中cache数组是静态的。

如上，再返回来看看我的笔试题：

public static void main(String[] args){
Integer i1=127,i2=127,i3=128,i4=128;
System.out.println(i1==i2);
System.out.println(i1.equals(i2));
System.out.println(i3==i4);
System.out.println(i3.equals(i4));
}

其中。i1与i2均指向常量池中的常量，即指向同一个对象，而i3和i4均为new Integer()后的产物，即产生不同的两个对象，指向不同的对象。
所以 结果是：

true true false true

---

---

其他的基本类型常量池使用的源码举例：

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

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