Java包装类的缓存机制原理实例是什么-创新互联

这篇文章给大家介绍Java包装类的缓存机制原理实例是什么，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

java 包装类的缓存机制，是在Java 5中引入的一个有助于节省内存、提高性能的功能，只有在自动装箱时有效

Integer包装类

举个栗子：

Integer a = 127;Integer b = 127;System.out.println(a == b);

这段代码输出的结果为true

使用自动装箱将基本类型转为封装类对象这个过程其实底层实现是调用封装类的valueOf方法：

Integer a =127; 相当于 Integer a = Integer.valueOf(127);

看一下Integer的valueOf方法：

public static Integer valueOf(int i) {  if (i >= IntegerCache.low && i <= IntegerCache.high)    return IntegerCache.cache[i + (-IntegerCache.low)];  return new Integer(i);}

如果入参 i 大于等于IntegerCache.low或者小于等于IntegerCache.high)，就从IntegerCache中获取对象

看一下IntegerCache：

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之间，范围的较大值可以通过java.lang.Integer.IntegerCache.high设置，通过for循环将范围内的数据实例化为Integer对象放到cache数组里

在测试一下：

Integer a = 128;Integer b = 128;System.out.println(a == b);

输出结果为false，所以如果没有指定cache较大值时，在-128到127之间使用自动装箱时，会使用缓存

Byte包装类

再举个栗子：

public static void main(String[] args) {  Byte a = 127;  Byte b = 127;  System.out.println(a == b); //true}

由于Byte范围在-128到127之间，所以Byte的valueOf都是从ByteCache缓存中获取的

public static Byte valueOf(byte b) {  final int offset = 128;  return ByteCache.cache[(int)b + offset];}

ByteCache类：

private static class ByteCache {  private ByteCache(){}  static final Byte cache[] = new Byte[-(-128) + 127 + 1];  static {    for(int i = 0; i < cache.length; i++)      cache[i] = new Byte((byte)(i - 128));  }}

与IntegerCache相比，ByteCache的较大值是不能修改的就是127

Short包装类

public static Short valueOf(short s) {  final int offset = 128;  int sAsInt = s;  if (sAsInt >= -128 && sAsInt <= 127) { // must cache    return ShortCache.cache[sAsInt + offset];  }  return new Short(s);}

ShortCache类：

private static class ShortCache {  private ShortCache(){}  static final Short cache[] = new Short[-(-128) + 127 + 1];  static {    for(int i = 0; i < cache.length; i++)      cache[i] = new Short((short)(i - 128));  }}

ShortCache的较大值也不可以修改，范围只能在-128 ~ 127之间

Long包装类的valueOf方法和LongCache类与Short包装类的实现一致，范围也是只能在-128 ~ 127之间

Character包装类

valueOf方法：

public static Character valueOf(char c) {  if (c <= 127) { // must cache    return CharacterCache.cache[(int)c];  }  return new Character(c);}

CharacterCache类：

private static class CharacterCache {  private CharacterCache(){}  static final Character cache[] = new Character[127 + 1];  static {    for (int i = 0; i < cache.length; i++)      cache[i] = new Character((char)i);  }}

Character的缓存范围在0 ~ 127之间

Boolean包装类

valueOf方法：

public static Boolean valueOf(boolean b) {  return (b ? TRUE : FALSE);}

TRUE跟FALSE都是static final修饰的静态变量

public static final Boolean TRUE = new Boolean(true);public static final Boolean FALSE = new Boolean(false);

Float包装类 & Double包装类

valueOf方法：

public static Float valueOf(float f) {  return new Float(f);}public static Double valueOf(double d) {  return new Double(d);}

Float和Double没有使用缓存，直接new的对象

总结：

java的包装类中：Byte，Short，Integer，Long，Character使用static代码块进行初始化缓存，其中Integer的较大值可以通过java.lang.Integer.IntegerCache.high设置；Boolean使用static final实例化的对象；Float和Double直接new的对象没有使用缓存

关于Java包装类的缓存机制原理实例是什么就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。