一道Integer面试题引发的对Integer的探究

　　

面试题：

//在jdk1.5的环境下，有如下4条语句：

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);

以下输出结果为false的是：

A.   System.out.println(i01== i02);
B.   System.out.println(i01== i03);
C.   System.out.println(i03== i04);
D.   System.out.println(i02== i04);

1.题目中提到了，是Jdk1.5的环境。

OK,我们新建一个项目，新建一个类，把代码复制进去。将Java Compiler设置为1.5.  关于这个版本的问题稍后再谈。

2.这里有两个数据类型，int和Integer。

   int为基本类型。

   Integer为对象类型。Integer的类声明是这样的：

public final class Integer extends Number implements Comparable<Integer> {

    //...

}

1、Integer类是final的，不能被继承

2、Integer类实现了Comparable接口，所以可以用compareTo进行比较。

3、Integer继承了Number类，所以该类可以调用longValue、floatValue、doubleValue等系列方法返回对应的类型的值。

3.题目中声明了三个Integer变量，i01,i03,i04.这三种声明方式有啥区别呢？

3.1  Integer i04 = new Integer(59); 做了什么？

看源码，这个构造函数是这样的：

    /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

    /**
     * Constructs a newly allocated {@code Integer} object that
     * represents the specified {@code int} value.
     *
     * @param   value   the value to be represented by the
     *                  {@code Integer} object.
     */
    public Integer(int value) {
       this.value = value;
    }

new Integer(59)的这个操作，调用了构造函数，将59这个值，赋给了Integer的局部变量value。

3.2  Integer i03 = Integer.valueOf(59); //这个 Integer.valueOf 方法又做了什么？？

看Integer.valueOf源码:

    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

这里，valueOf方法先判断传入参数的值，满足if 条件的话，则返回cache值。

否则 new 一个Integer 返回。这里的 if中的条件 IntegerCache.high=127， IntegerCache.low=-128；从IntegerCache的类定义可以看出，IntegerCache里边定义了一个数组cache用来存储Integer对象，静态块里边完成了数组的初始化，存入了-128到127之间的Integer对象：

    private static class IntegerCache {//这个类是 Integer 类的 静态内部类。看这个代码不难发现，在Integer加载之后这个内部类的cache数组里边就初始化了-128到127之间的值
        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) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low));
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

所以，对于Integer.valueOf（i）方法 ， 当i在-128-127之间时返回的是缓存的Integer对象。 否则返回的是一个新的Integer对象。

这里传递的是59，所以返回的是cache里边的对象。

3.3 Integer i01 = 59;// 这句话又做了什么？

我们将源码产生的class文件反编译发现如下：

源码：   
public static void main(String[] args) {
        // TODO Auto-generated method stub

        Integer i01 = 59;// Integer.valueOf(59);
        int i02 = 59;
        Integer i03 = Integer.valueOf(59);
        Integer i04 = new Integer(59);
        System.out.println("i01 == i02:" + (i01 == i02)); 
        System.out.println("i01 == i03:" + (i01 == i03));
        System.out.println("i03 == i04:" + (i03 == i04));
        System.out.println("i02 == i04:" + (i02 == i04)); 
        
    }
反编译之后：

public static void main(String[] args)
{
Integer i01 = Integer.valueOf(59);
int i02 = 59;
Integer i03 = Integer.valueOf(59);
Integer i04 = new Integer(59);
System.out.println("i01 == i02:" + (i01.intValue() == i02));
System.out.println("i01 == i03:" + (i01 == i03));
System.out.println("i03 == i04:" + (i03 == i04));
System.out.println("i02 == i04:" + (i02 == i04.intValue()));
}

可以发现：Integer i01=59;在反编译过来之后是Integer.valueOf(59);

在用Integer 类型的i01和int类型的i02进行“==”比较的时候，反编译过来的是：i01.intValue() == i02

这两个操作分别为 自动装箱 和自动拆箱。这个特性是在java1.5开始才有的。所以第一点中提到了jdk版本为1.5.

如果我们在eclipse/myeclipse 中将java compiler设置成1.5以下的就会无法通过编译：

Type mismatch: cannot convert from int to Integer

通过上面的分析，这题就不难得出答案了。

i01 == i02 等价于  i01.intValue()==i02  两个值的比较59==59   -->true;

i01 == i03 由于 59在-128到127之间，所以，i01和i03的赋值操作返回的是同一个对象。都是从chche中返回的同一个对象，对象地址相同   true;

i03 == i04 i03是来自缓存值，i04是新new的对象 ，二者不是同一个对象，所以false。

i02 == i04 和第一个类似，true。