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
public void boxingTest() {
  
Integer i1 = 17 ;
Integer i2 = 17 ;
  
Integer i3 = 137 ;
Integer i4 = 137 ;
  
System.out.println(i1 == i2);
11 System.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
*/
public static Integer valueOf( int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new 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. 自动拆箱
     自动拆箱就是将包装器类型转换为基本数据类型,如将Integer 转换为int ,Float 转换为float 等;
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @Test
    public void unboxingTest() {
    Integer i1 = 17 ;
    int i2 = 17 ;
      
    int i3 = 137 ;
    Integer i4 = 137 ;
      
    System.out.println(i1 == i2);
    10 System.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}.
    */
    public int intValue() {
    return value;
    }


    如:

    清单3内容如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @Test
    public void 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));
    15 System.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.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false ;
}
  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
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;
  
// 会自动拆箱(会调用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.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false ;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值