java : 包装类 缓冲机制的使用

十一、包装类
缓存
byte Byte -128–127
short Short -128–127
int Integer -128—127
long Long -128—127
float Float 不缓存
double Double 不缓存
char Character 0–127
boolean Boolean TURE，FALSE

Integer{
int value;
}

装箱：将基本类型值转换成对象类型
Integer i = new Integer(100);
拆箱：将对象类型的值取出赋值给基本类型变量
int i2 = i.intValue();

jdk5.0之后，采用自动装箱和自动拆箱：
自动装箱：
Integer i = 100;===>i = Integer.valueOf(100);
自动拆箱：
int i1 = i.intValue();

---

转：http://blog.sina.com.cn/s/blog_7ffb8dd5010123lt.html

为了了解缓冲机制的使用，我们先从Integer 与 int的互转入手：

JDK1.5为Integer增加了一个全新的方法：
Java代码 收藏代码

public static Integer valueOf(int i)  

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

int i = 0;  Integer wrapperi = Integer.valueOf(i);  

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

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

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

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

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这个类，此类代码如下

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=

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。

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的整数。 而重载的valueOf(String s)，valueOf(String s, int radix)是没有使用缓冲机制的

综上所述： （通过查询底层代码得知：）
八种基本数据类型和其包装类中 Integer valueOf(int i)、Byte valueOf(byte b)、Short valueOf(short s)、Long valueOf(long l)、Character valueOf(char c)都是用到了缓冲机制，并且缓冲的范围都是-128~127
但是，对于包装类Float,Double,Boolean 并没有提供相应的缓冲机制