Iteger int

.Java的Integer与int互转 博客分类： java面试题
JavaCacheJ#JDK .
int转Integer

Java代码 
1.int i = 0;  
2.Integer wrapperi = new Integer(i); 
int i = 0;
Integer wrapperi = new Integer(i);


Integer转int

Java代码 
1.Integer wrapperi = new Integer(0);  
2.int i = wrapperi.intValue(); 
Integer wrapperi = new Integer(0);
int i = wrapperi.intValue();




JDK1.5以后的int转Integer
JDK1.5以后，Java为我们提供了更为丰富的转换方法。

其中最值得一提的就是自动装包/自动拆包(AutoBoxing/UnBoxing)。
此功能大大丰富了基本类型(primitive type)数据与它们的包装类(Wrapper Class)
的使用。

由于AutoBoxing的存在，以下代码在JDK1.5的环境下可以编译通过并运行。

Java代码 
1.int i = 0;  
2.Integer wrapperi = i; 
int i = 0;
Integer wrapperi = i;


还有其他方法？
JDK1.5为Integer增加了一个全新的方法：

Java代码 
1.public static Integer valueOf(int i) 
public static Integer valueOf(int i)
以下代码在JDK1.5的环境下可以编译通过并运行。

Java代码 
1.int i = 0;  
2.Integer wrapperi = Integer.valueOf(i); 
int i = 0;
Integer wrapperi = Integer.valueOf(i);


此方法与new Integer(i)的不同处在于：
方法一调用类方法返回一个表示指定的 int 值的 Integer 实例。
方法二产生一个新的Integer对象。

JDK API文档中对这个新的valueOf方法有明确的解释：
如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提

高空间和时间性能。

但这个解释有点晦涩难懂。为什么该方法有可能通过缓存经常请求的值而显著提高性能？

通过反编译工具查看valueOf方法。

Java代码 
1. /*   
2.  * 返回一个表示指定的 int 值的 Integer 实例。如果不需要新的 Integer 实例，则   
3.  * 通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过   
4.  * 缓存经常请求的值而显著提高空间和时间性能。    
5.  * @param  i an <code>int</code> value.   
6.  * @return a <tt>Integer</tt> instance representing <tt>i</tt>.   
7.  * @since  1.5   
8.  */    
9.public static Integer valueOf(int i) {     
10.      final int offset = 128;     
11.      if (i >= -128 && i <= 127) { // must cache      
12.        return IntegerCache.cache[i + offset];     
13.     }     
14.     return new Integer(i);     
15.}   
/* 
  * 返回一个表示指定的 int 值的 Integer 实例。如果不需要新的 Integer 实例，则 
  * 通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过 
  * 缓存经常请求的值而显著提高空间和时间性能。  
  * @param  i an <code>int</code> value. 
  * @return a <tt>Integer</tt> instance representing <tt>i</tt>. 
  * @since  1.5 
  */ 
public static Integer valueOf(int i) {  
      final int offset = 128;  
      if (i >= -128 && i <= 127) { // must cache   
        return IntegerCache.cache[i + offset];  
     }  
     return new Integer(i);  
} 


可以看到对于范围在-128到127的整数，valueOf方法做了特殊处理。
采用IntegerCache.cache[i + offset]这个方法。
从名字，我们可以猜出这是某种缓存机制。

进一步跟踪IntegerCache这个类，此类代码如下

Java代码 
1./*   
2.  * IntegerCache内部类   
3.  * 其中cache[]数组用于存放从-128到127一共256个整数   
4.  */    
5.private static class IntegerCache {     
6.    private IntegerCache(){}     
7.    
8.    static final Integer cache[] = new Integer[-(-128) + 127 + 1];     
9.    
10.    static {     
11.        for(int i = 0; i < cache.length; i++)     
12.        cache[i] = new Integer(i - 128);     
13.    }     
14.}   
/* 
  * IntegerCache内部类 
  * 其中cache[]数组用于存放从-128到127一共256个整数 
  */ 
private static class IntegerCache {  
    private IntegerCache(){}  
 
    static final Integer cache[] = new Integer[-(-128) + 127 + 1];  
 
    static {  
        for(int i = 0; i < cache.length; i++)  
        cache[i] = new Integer(i - 128);  
    }  
} 


这就是valueOf方法真正的优化方法，当-128=<i<=127的时候，返回的是IntegerCache中的数组的值；当 i>127 或 i<-128 时，返回的是

Integer类对象。

再举一个经常被提到的例子

Java代码 
1.Integer i=100;  
2.Integer j=100;  
3.//print true  
4.System.out.println(i==j); 
Integer i=100;
Integer j=100;
//print true
System.out.println(i==j);

此时的 i=IntegerCache.cache[i + 128] = IntegerCache.cache[228]，
同样j = IntegerCache.cache[j + 128] = IntgerCache.cache[228]
因此 Integer引用i中存储的是cache数组第228号元素的地址。同理j也是同一个cache数组的第228号元素的地址(因为cache是Integer的static

数组，只有一个)。
i==j比较的是引用地址，因此返回true。


Java代码 
1.Integer i=200;  
2.Integer j=200;  
3.//print false  
4.System.out.println(i==j);  
Integer i=200;
Integer j=200;
//print false
System.out.println(i==j);

此时的 i=new Integer(200);  同样j=new Integer(200) 。
两次都在堆中开辟了Integer的对象。
i 和 j 中存储的堆的对象地址是完全不同的。i==j 自然返回false。


引入缓存机制的作用何在？

接着上面的例子，假如我们在编程时大量需要值为100（100的范围在-128到127之间）的Integer对象。如果只能通过new来创建，需要在堆中开

辟大量值一样的Integer对象。
这是相当不划算的，IntegerCache.cache很好的起到了缓存的作用。
当我们需要Integer i  = 100的时候，直接从cache中取出第[100+128]号元素的地址赋值给引用i，再次需要Integer j = 100时，还是直接去这

个地址赋值给j。是不是省去了在堆中不停的创建对象的代价了(空间，时间上的消耗都很大)。 这就是valueOf方法真正的提高性能之处。
正如JDK API文档对valueOf(int i)方法的描述，该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。

结论

valueOf(int i)的优化只针对于范围在-128到127的整数。




JDK1.5以后的Integer转int
由于UnBoxing的存在，以下代码在JDK1.5的环境下可以编译通过并运行。

Java代码 
1.Integer wrapperi = new Integer(0);  
2.int i = wrapperi; 
Integer wrapperi = new Integer(0);
int i = wrapperi;








附：AutoBoxing与UnBoxing带来的转变
在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀。

以下代码在JDK1.5中成为了可能，试想下在JDK1.5之前该如何实现这段代码？

Java代码 
1.int x = 1;   
2.Collection collection = new ArrayList();   
3.collection.add(x);//AutoBoxing,自动转换成Integer.   
4.Integer y = new Integer(2);   
5.collection.add(y + 2); //y + 2为UnBoxing，自动转换成int。之后再次转换为Integer。 
int x = 1;
Collection collection = new ArrayList();
collection.add(x);//AutoBoxing,自动转换成Integer.
Integer y = new Integer(2);
collection.add(y + 2); //y + 2为UnBoxing，自动转换成int。之后再次转换为Integer。


此特性同样适用于Map

Java代码 
1.Map map = new HashMap();  
2.int x = 1;  
3.Integer y = new Integer(2);  
4.int z = 3;  
5.map.put(x,y + z);//x自动转换成Integer。y+z自动转换成int。之后再次转换为Integer。