java 自动拆箱(unboxing)和自动装箱（boxing）

首先了解下Java的四类八种基本数据类型：

基本类型占用空间（Byte）表示范围包装器类型

boolean

1/8

true|false

Boolean

char

2

-128~127

Character

byte

1

-128~127

Byte

short

2

-2ˆ15~2ˆ15-1

Short

int

4

-2ˆ31~2ˆ31-1

Integer

long

8

-2ˆ63~2ˆ63-1

Long

float

4

-3.403E38~3.403E38

Float

double

8

-1.798E308~1.798E308

Double

自动装箱

   所谓的自动装箱就是将基本的数据类型自动转换为包装类型，如int自动转换为Integer

   如下清单1：

1

2

3

4

5

6

7

8

9

10

11

12

@Test

publicvoid boxingTest() {

  

Integer i1 = 17;

Integer i2 = 17;

  

Integer i3 = 137;

Integer i4 = 137;

  

System.out.println(i1 == i2);

11System.out.println(i3 == i4);

}

输出：

1

2

true

false

   

解释下清单1第11句输出true的原因：

当包装器类型进行“==”比较时，i3会调用Integer.valueOf自动装箱基本数据类型为包装器类型。

及 当Integer 和另一个Integer 进行比较的时候，会先调用Integer.valueof 这个方法将对应的包装器类型的基本数据类型转换为包装器类型

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

/**

* 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

*/

publicstatic Integer valueOf(inti) {

if(i >= IntegerCache.low && i <= IntegerCache.high)

returnIntegerCache.cache[i + (-IntegerCache.low)];

returnnew Integer(i);

}

从源码中可以看出，Integer对象自动缓存int值范围在low~high（-128~127），所有对于17 是没有重新new一个对象，而是直接返回缓存中的Integer对象，如果超出这个范围则会自动装箱为包装类，及new 一个新的对象，所以两个137就new了两次Integer 对象，所以他们是不相等的。

  

1. Integer、Short、Byte、Character、Long这几个包装类的valueOf方法的实现是类似的；
2. Double、Float的valueOf方法的实现是类似的。
3. Boolean的valueOf方法的实现是个三目运算，形如`  return (b ? TRUE : FALSE);  `
   
   

1. 
   

1. 自动拆箱
    自动拆箱就是将包装器类型转换为基本数据类型，如将Integer 转换为int ,Float 转换为float 等；
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   @Test

   publicvoid unboxingTest() {

   Integer i1 = 17;

   inti2 = 17;

     

   inti3 = 137;

   Integer i4 = 137;

     

   System.out.println(i1 == i2);

   10System.out.println(i3 == i4);

     

   }

   输出：

   1

   2

   true

   true
   当 包装器类型与基本类型进行“==”比较时 ，包装器类型会调用Integer.intValur() 进行自动拆箱为基本数据类型；
   
   1
   2
   3
   4
   5
   6
   7
   /**

   * Returns the value of this {@code Integer} as an

   * {@code int}.

   */

   publicint intValue() {

   returnvalue;

   }
   
   
   如：
   

   清单3内容如下：

   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   @Test

   publicvoid unboxingTest() {

   Integer i1 = 17;

   Integer i2 = 17;

     

   Integer i3 = 137;

   Integer i4 = 137;

     

   // ==

   System.out.println(i1 == i2);

   System.out.println(i3 == i4);

     

   // equals

   System.out.println(i1.equals(i2));

   15System.out.println(i3.equals(i4));

     

   }

   输出：

   1

   2

   3

   4

   true

   false

   true

   true
   当包装器类型与包装器类型进行“equals()”比较时， 首先是判断是否为同一类型，如果是同一类型，在进行拆箱转换为基本数据类型进行比较，相等这返回true，否则返回false；
   如： Integer 中的equals()代码：

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/**

* Compares this object to the specified object. The result is

* {@code true} if and only if the argument is not

* {@code null} and is an {@code Integer} object that

* contains the same {@code int} value as this object.

*

* @param obj the object to compare with.

* @return {@code true} if the objects are the same;

* {@code false} otherwise.

*/

publicboolean equals(Object obj) {

if(obj instanceofInteger) {

returnvalue == ((Integer)obj).intValue();

}

returnfalse;

}


1. Integer、Short、Byte、Character、Long这几个包装类的intValue方法的实现是类似的；
2. Double、Float的intValue方法的实现是类似的。
3. Boolean的booleanValue方法的实现和intValue方法的实现也是类似的。

装箱拆箱综合清单：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

publicstatic 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;

  

// 会自动拆箱（会调用intValue方法）

System.out.println(c==d);

// 会自动拆箱后再自动装箱

System.out.println(e==f);

// 虽然“==”比较的是引用的是否是同一对象，但这里有算术运算，如果该引用为包装器类型则会导致自动拆箱

System.out.println(c==(a+b));

// equals 比较的是引用的对象的内容（值）是否相等，但这里有算术运算，如果该引用为包装器类型则会导

 // 致自动拆箱，再自动装箱

// a+b触发自动拆箱得到值后，再自动装箱与c比较

System.out.println(c.equals(a+b));

// 首先a+b触发自动拆箱后值为int型，所以比较的是值是否相等

System.out.println(g==(a+b));

// 首先a+b触发自动拆箱后值为int型，自动装箱后为Integer型，然后g为Long型

System.out.println(g.equals(a+b));

// 首先a+h触发自动拆箱后值为long型，因为int型的a会自动转型为long型的g然后自动装箱后为Long型，

 // 而g也为Long型

System.out.println(g.equals(a+h));

  

}

输出：

1

2

3

4

5

6

7

true

false

true

true

true

false

true

 这里面需要注意的是：当 “==”运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）另外，对于包装器类型，equals方法并不会进行类型转换。

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/**

* Compares this object to the specified object. The result is

* {@code true} if and only if the argument is not

* {@code null} and is an {@code Integer} object that

* contains the same {@code int} value as this object.

*

* @param obj the object to compare with.

* @return {@code true} if the objects are the same;

* {@code false} otherwise.

*/

publicboolean equals(Object obj) {

if(obj instanceofInteger) {

returnvalue == ((Integer)obj).intValue();

}

returnfalse;

}