java自动装箱、拆箱

什么是自动装箱拆箱

基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。

一般我们要创建一个类的对象实例的时候，我们会这样：

Class a = new Class(parameter);

当我们创建一个Integer对象时，却可以这样：

Integer i = 100; (注意：不是 int i = 100; )

实际上，执行上面那句代码的时候，系统为我们执行了：Integer i = Integer.valueOf(100);

此即基本数据类型的自动装箱功能。

基本数据类型与对象的差别

基本数据类型不是对象，也就是使用int、double、boolean等定义的变量、常量。

基本数据类型没有可调用的方法。

eg： int t = 1； t. 后面是没有方法滴。

Integer t =1； t. 后面就有很多方法可让你调用了。

什么时候自动装箱

例如：Integer i = 100;

相当于编译器自动为您作以下的语法编译：Integer i = Integer.valueOf(100);

什么时候自动拆箱

　　自动拆箱(unboxing)，也就是将对象中的基本数据从对象中自动取出。如下可实现自动拆箱：

 Integer i = 10; //装箱   int t = i; //拆箱，实际上执行了 int t = i.intValue(); 

在进行运算时，也可以进行拆箱。

 Integer i = 10;  System.out.println(i++);

Integer的自动装箱

//在-128~127 之外的数 Integer i1 =200;   Integer i2 =200;           System.out.println("i1==i2: "+(i1==i2));                    // 在-128~127 之内的数 Integer i3 =100;   Integer i4 =100;   System.out.println("i3==i4: "+(i3==i4));

　　 输出的结果是：

    i1==i2: false    i3==i4: true

说明：

equals() 比较的是两个对象的值（内容）是否相同。

“==” 比较的是两个对象的引用（内存地址）是否相同，也用来比较两个基本数据类型的变量值是否相等。

前面说过，int 的自动装箱，是系统执行了 Integer.valueOf(int i)，先看看Integer.java的源码：

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

对于–128到127（默认是127）之间的值，Integer.valueOf(int i) 返回的是缓存的Integer对象（并不是新建对象）

所以范例中，i3 与 i4实际上是指向同一个对象。

而其他值，执行Integer.valueOf(int i) 返回的是一个新建的 Integer对象，所以范例中，i1与i2 指向的是不同的对象。

当然，当不使用自动装箱功能的时候，情况与普通类对象一样，请看下例：

 Integer i3 =new Integer(100);  Integer i4 =new Integer(100);  System.out.println("i3==i4: "+(i3==i4));//显示false

String 的拆箱装箱

先看个例子：

1 String str1 ="abc";2 String str2 ="abc";3 System.out.println(str2==str1); //输出为 true 4 System.out.println(str2.equals(str1)); //输出为 true 5   6 String str3 =new String("abc");7 String str4 =new String("abc"); 8 System.out.println(str3==str4); //输出为 false 9 System.out.println(str3.equals(str4)); //输出为 true

　　这个怎么解释呢？貌似看不出什么。那再看个例子。

 String d ="2";  String e ="23"; e = e.substring(0, 1); System.out.println(e.equals(d)); //输出为 true  System.out.println(e==d); //输出为 false

第二个例子中，e的初始值与d并不同，因此e与d是各自创建了个对象，（e==d）为false 。
同理可知，第一个例子中的str3与str4也是各自new了个对象，而str1与str2却是引用了同一个对象。

原帖（http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html）

---

---

因为在学习集合时知道集合里存放的对象都是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() {}      }  

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

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

答案是都为false！至于具体为什么，读者可以去查看Double类的valueOf的实现。
　　在这里只解释一下为什么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);      }  }  

答案是都为true！
至于为什么是这个结果，看了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了。

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

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

先别看输出结果，读者自己想一下这段代码的输出结果是什么。这里面需要注意的是：当 “==”运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。另外，对于包装器类型，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方法）。

原帖（http://blog.csdn.net/zhangliangzi/article/details/50552587）