您的位置：首页 > 其它

Integer的自动装箱与自动拆箱注意事项

2017-05-21 00:00 309 查看
摘要: 本文摘自一篇面试大全其中的一个片段

int和Integer有什么区别？
答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。
Java 为每个原始类型提供了包装类型：
- 原始类型: boolean，char，byte，short，int，long，float，double
- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

1
2
3
4
5
6
7
8
9
10
class
AutoUnboxingTest {


public
 
static
 
void
 
main(String[] args) {

Integer a =
new
 
Integer(
3
);

Integer b =
3
;  
// 将3自动装箱成Integer类型

int
 
c =
3
;

System.out.println(a == b); 
// false 两个引用没有引用同一对象

System.out.println(a == c); 
// true a自动拆箱成int类型再和c比较

}

}

最近还遇到一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：

1
2
3
4
5
6
7
8
9
public
 
class
 
Test03 {


public
 
static
 
void
 
main(String[] args) {

Integer f1 =
100
, f2 =
100
, f3 =
150
, f4 =
150
;


System.out.println(f1 == f2);

System.out.println(f3 == f4);

}

}

如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。

1
2
3
4
5
public
 <
3ff0
code>static 
Integer valueOf(
int
 
i) {

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

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

return
 
new
 
Integer(i);

}

IntegerCache是Integer的内部类，其代码如下所示：

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
32
33
34
35
36
37
38
39
40
41
42
43
44
/**

 
* Cache to support the object identity semantics of autoboxing for values between

 
* -128 and 127 (inclusive) as required by JLS.

 
*

 
* The cache is initialized on first usage.  The size of the cache

 
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>}option.

 
* During VM initialization, java.lang.Integer.IntegerCache.high property

 
* may be set and saved in the private system properties in the

 
* sun.misc.VM class.

 
*/


private
 
static
 
class
 
IntegerCache {

static
 
final
 
int
 
low = -
128
;

static
 
final
 
int
 
high;

static
 
final
 
Integer cache[];


static
 
{

// high value may be configured by property

int
 
h =
127
;

String integerCacheHighPropValue =

sun.misc.VM.getSavedProperty(
"java.lang.Integer.IntegerCache.high"
);

if
 
(integerCacheHighPropValue !=
null
) {

try
 
{

int
 
i = parseInt(integerCacheHighPropValue);

i = Math.max(i,
127
);

// Maximum array size is Integer.MAX_VALUE

h =Math.min(i, Integer.MAX_VALUE - (-low) -
1
);

}
catch
( NumberFormatException nfe) {

// If the property cannot be parsed into an int, ignore it.

}

}

high =h;


cache =
new
 
Integer[(high - low) +
1
];

int
 
j = low;

for
(
int
 
k =
0
; k < cache.length; k++)

cache[k] =
new
 
Integer(j++);


// range [-128, 127] must be interned (JLS7 5.1.7)

assert
 
IntegerCache.high >=
127
;

}


private
 
IntegerCache() {}

}

简单的说，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。

提醒：越是貌似简单的面试题其中的玄机就越多，需要面试者有相当深厚的功力。
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航