new Integer()和Integer.valueOf()效率比较

Integer a=new Integer(1) 

Integer a=Integer.valueOf(1); 

两个都是得到一个Integer对象，但是Integer.valueOf的效率高。为什么呢？因为Integer.valueOf用到了缓存。看看Integer.valueOf的代码： 

Java代码 
1.<SPAN style="FONT-SIZE: small">    public static Integer valueOf(int i) {   
2.    final int offset = 128;   
3.    if (i >= -128 && i <= 127) { // must cache   
4.        return IntegerCache.cache[i + offset];   
5.    }   
6.        return new Integer(i);   
7.    }</SPAN>  
    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); 
    } 

当传入的整数i：-128<i<=127时，从缓存里取出整数对应的Integer对象，否则创建一个Integer对象。基本上平时的程序中，这个范围的整数是最常用的。 


  IntegerCache是什么？看看源码 

Java代码 
1.<SPAN style="FONT-SIZE: small">    private static class IntegerCache {   
2.    private IntegerCache(){}   
3.  
4.    static final Integer cache[] = new Integer[-(-128) + 127 + 1];   
5.  
6.    static {   
7.        for(int i = 0; i < cache.length; i++)   
8.        cache[i] = new Integer(i - 128);   
9.    }   
10.    }</SPAN>  
    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); 
    } 
    } 


可见，IntegerCache预先创建了这些Integer对象。 


所以，要注意的是，new Integer返回的永远是不同的对象，但是当整数范围在-128<i<=127时，Integer.valueOf返回的是同一个对象。看看下面代码： 

Java代码 
1.<SPAN style="FONT-SIZE: small">        Integer a=new Integer(1);   
2.        Integer b=new Integer(1);   
3.          
4.        //整数范围在-128到127之间，返回的是同一个对象   
5.        Integer c=Integer.valueOf(1);   
6.        Integer d=Integer.valueOf(1);   
7.          
8.        //返回的不是同一个对象   
9.        Integer e=Integer.valueOf(200);   
10.        Integer f=Integer.valueOf(200);   
11.          
12.        System.out.println(a==b);   
13.        System.out.println(c==d);   
14.        System.out.println(e==f);</SPAN>  
        Integer a=new Integer(1); 
        Integer b=new Integer(1); 
       
        //整数范围在-128到127之间，返回的是同一个对象 
        Integer c=Integer.valueOf(1); 
        Integer d=Integer.valueOf(1); 
       
        //返回的不是同一个对象 
        Integer e=Integer.valueOf(200); 
        Integer f=Integer.valueOf(200); 
       
        System.out.println(a==b); 
        System.out.println(c==d); 
        System.out.println(e==f); 


输出为 

false 
true 
false 

结论：在没有对Integer创建有特殊要求时，比如纯数字计算或比较，最好用Integer.valueOf。 

原文链接：http://jameswxx.iteye.com/blog/808747