Biegral Blog

因为在学习集合时知道集合里存放的对象都是Object类型，取出的时候需要强制类型转换为目标类型（使用泛型集合不需要），如int a = (Integer)arrayList.get(0)；然后我们就会发现，为什么要强制转换为Integer，而不是int呢？int与Integer有什么区别呢？

1、基本类型与包装类区别

int是基本类型，直接存数值；如：

int i = 5；//直接在栈中分配空间，存放5这个数值

Integer是int的包装类，是类，拥有方法；如：

Integer i = new Integer(5);	//i是对象的引用变量，所以在堆内存中分配对象空间，栈中存放堆内存中对应空间的地址

Java有八种基本数据类型，对应八种包装类：

short Short

int Integer

long Long

char Character

byte Byte

float Float

boolean Boolean

double Double

变量的值存储在栈里，而对象存储在堆里，相比而言，堆栈更高效，这也是java保留基本类型的原因。包装类创建的对象，可以使用api提供的一些有用的方法。更为强大。

2、自动装箱与自动拆箱

那我们来分析Integer i = 5;的过程；

在jdk1.5以前，这样的代码是错误的，必须要通过Integer i = new Integer(5);这样的语句实现；而在jdk1.5以后，Java提供了自动装箱的功能，只需Integer i = 5;这样的语句就能实现基本数据类型传给其包装类，JVM为我们执行了Integer i = Integer.valueOf(5);这就是Java的自动装箱。

相对应的，把基本数据从对应包装类中取出的过程就是拆箱；如

Integer i = 5；

int j = i;//这样的过程就是自动拆箱

源码方面，用一句话总结装箱和拆箱的实现过程：

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

Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别：
1）第一种方式不会触发自动装箱的过程；而第二种方式会触发；
2）在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。

3、源码问题、面试问题：（参考http://www.cnblogs.com/dolphin0520/p/3780005.html）

a、这里就有一个面试经常会出现的问题，看下面这段代码：

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

true

false

出现这样结果的原因可由源码解释：

public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)　　// 没有设置的话，IngegerCache.high 默认是127
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

而其中IntegerCache类的实现为：

private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                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() {}
    }

b、而如果把上一道题中的四个数据类型换做Double或Float，那么结果是什么？

public static void main(String[] args) {
         
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

　　在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。
注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的。

c、换做Boolean呢？

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

至于为什么是这个结果，看了Boolean类的源码也会一目了然。下面是Boolean的valueOf方法的具体实现：

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

而其中的 TRUE 和FALSE又是什么呢？在Boolean中定义了2个静态成员属性：

 public static final Boolean TRUE = new Boolean(true);

    /** 
     * The <code>Boolean</code> object corresponding to the primitive 
     * value <code>false</code>. 
     */
    public static final Boolean FALSE = new Boolean(false);

至此，大家应该明白了为何上面输出的结果都是true了。

public class Main {
    public static void main(String[] args) {
         
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
         
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(c==(a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));
    }
}

true
false
true
true
true
false
true