面试题:基础数据类型 包装类 int Integer

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

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

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

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

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

1. 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、这里就有一个面试经常会出现的问题，看下面这段代码：

1. public class Main {
2. public static void main(String[] args) {
3. Boolean i1 = false;
4. Boolean i2 = false;
5. Boolean i3 = true;
6. Boolean i4 = true;
7. System.out.println(i1==i2);
8. System.out.println(i3==i4);
9. }
10. }

输出结果是什么呢？

true

false

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

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

而其中IntegerCache类的实现为：

1. private static class IntegerCache {
2. static final int high;
3. static final Integer cache[];
4. static {
5. final int low = -128;
6. // high value may be configured by property
7. int h = 127;
8. if (integerCacheHighPropValue != null) {
9. // Use Long.decode here to avoid invoking methods that
10. // require Integer's autoboxing cache to be initialized
11. int i = Long.decode(integerCacheHighPropValue).intValue();
12. i = Math.max(i, 127);
13. // Maximum array size is Integer.MAX_VALUE
14. h = Math.min(i, Integer.MAX_VALUE - -low);
15. }
16. high = h;
17. cache = new Integer[(high - low) + 1];
18. int j = low;
19. for(int k = 0; k < cache.length; k++)
20. cache[k] = new Integer(j++);
21. }
22. private IntegerCache() {}
23. }

从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
　　上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。

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

1. public static void main(String[] args) {
2. Double i1 = 100.0;
3. Double i2 = 100.0;
4. Double i3 = 200.0;
5. Double i4 = 200.0;
6. System.out.println(i1==i2);
7. System.out.println(i3==i4);
8. }
9. }

答案是都为false！至于具体为什么，读者可以去查看Double类的valueOf的实现。

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

c、换做Boolean呢？

1. public class Main {
2. public static void main(String[] args) {
3. Boolean i1 = false;
4. Boolean i2 = false;
5. Boolean i3 = true;
6. Boolean i4 = true;
7. System.out.println(i1==i2);
8. System.out.println(i3==i4);
9. }
10. }

答案是都为true！

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

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

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

1. public static final Boolean TRUE = new Boolean(true);
2. /**
3. * The <code>Boolean</code> object corresponding to the primitive
4. * value <code>false</code>.
5. */
6. public static final Boolean FALSE = new Boolean(false);

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

d、下面这段代码输出什么？

1. public class Main {
2. public static void main(String[] args) {
3. Integer a = 1;
4. Integer b = 2;
5. Integer c = 3;
6. Integer d = 3;
7. Integer e = 321;
8. Integer f = 321;
9. Long g = 3L;
10. Long h = 2L;
11. System.out.println(c==d);
12. System.out.println(e==f);
13. System.out.println(c==(a+b));
14. System.out.println(c.equals(a+b));
15. System.out.println(g==(a+b));
16. System.out.println(g.equals(a+b));
17. System.out.println(g.equals(a+h));
18. }
19. }

先别看输出结果，读者自己想一下这段代码的输出结果是什么。这里面需要注意的是：当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。另外，对于包装器类型，equals方法并不会进行类型转换。明白了这2点之后，上面的输出结果便一目了然：

true
false
true
true
true
false
true

　第一个和第二个输出结果没有什么疑问。第三句由于  a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等。而对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。同理对于后面的也是这样，不过要注意倒数第二个和最后一个输出的结果（如果数值是int类型的，装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法）。