Java的Autoboxing and Unboxing（装箱拆箱）

参见（第二个网址的认识有误区）：

 

http://docs.oracle.com/javase/tutorial/java/data/autoboxing.html

http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html
  

什么是自动装箱拆箱

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

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

Class a = new Class(parameter);

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

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

实际上，执行上面那句代码的时候，系统为我们执行了基本数据类型的自动装箱功能。

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

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

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

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

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

什么时候自动拆箱

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

1    Integer i  =  10 ;  // 装箱 
2     int  t  =  i;  // 拆箱

　  在进行运算时，也可以进行自动装箱与拆箱。 

1  Integer i  =  10 ;
2  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() 比较的是两个对象的值（内容）是否相同，"==" 比较的是两个对象的引用（内存地址）是否相同，也用来比较两个基本数据类型的变量值是否相等。

在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，指定为静态全局数组的一个值；

如果超过了从–128到127之间的值，每次都新建了一个对象，即相当于每次装箱时都新建一个 Integer对象，所以范例中，i1与i2参考的是不同的对象。

源代码参考：

    
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() {}
    }

    // HERE!!!
    public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
 
        else
            return new Integer(i);
    }

    public static Float valueOf(float f) {
        return new Float(f);
    }

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

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

再看个例子：

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其实没有自动装箱或者拆箱的说法：

在C语言中，p和m的地址是相等的，因为他们存放在了字符串常量区，当字符串常量去一样时，编译器便会使他们指向同一“abc”。
  int *p = "abc";

  int *m = "abc";

java的String是不可变类。为了提高效率，java为String类提供了String池。

当我们使用形如String s="abc"的代码为字符串赋值时，JVM首先会检查字符串常量池中是否有"abc"这个字符串，如果有就直接将其地址赋给s；若没有，则在Stirng池中创建一个字符串对象“abc”，再将其地址赋给s。

这里，s是对象“abc”的引用，可以将引用理解为对象的地址。