Byte、Short、Integer、Long内部缓存类的对比与源码分析

推荐原创

这是 《水煮 JDK 源码》系列 的第7篇文章，计划撰写100篇关于JDK源码相关的文章

对于基本数据类型的包装类 Byte、Short、Integer、Long ，其内部实现都有一个缓存类，这个缓存类主要用于缓存固定区间的数值对象，默认为 [-128, 127]，其中 Integer 的缓存区间最大值可以通过属性动态配置，而 Byte、Short、Long 则不能动态配置。

在平时的开发过程中，可能对于这些包装类的内部缓存没有过多的关注，如果没有阅读过相关源码，也可能完全不知道还有内部缓存类的存在，但是下面的代码所展示的或许见过。

public static void main(String[] args) {
    Integer num1 = 100;
    Integer num2 = 100;
    System.out.println("num1 与 num2 是否相等：" + (num1 == num2));

    Integer num3 = 128;
    Integer num4 = 128;
    System.out.println("num3 与 num4 是否相等：" + (num3 == num4));
}

运行上面的代码，输出结果是什么呢？了解过 Integer 内部缓存池的可能会给出如下的结果

num1 与 num2 是否相等：true
num3 与 num4 是否相等：false

但是在此处，我想说的是，这个结果不完全正确，为什么呢？因为漏掉了另外一种可能的情况，准确来说，上面的程序运行可能会出现两种结果：

未改变 Integer 缓存区间最大值时，默认缓存区间为 [-128, 127]，此时上面程序输出结果如下
```
num1 与 num2 是否相等：true
num3 与 num4 是否相等：false
```
通过 java.lang.Integer.IntegerCache.high 属性改变了 Integer 缓存区间的最大值时，比如改变后的缓存区间为 [-128, 200]，那么此时上面程序的输出结果就不一样了，如下
```
num1 与 num2 是否相等：true
num3 与 num4 是否相等：true
```

为什么会这样呢？上面的程序定义涉及到 int 与 Integer 之间的装箱操作，而装箱操作是在编译时自动完成的，具体装箱操作调用的是 Integer 的 valueOf() 方法，而 valueOf() 方法的实现又与 Integer 的内部缓存类 IntegerCache 的实现有关，IntegerCache 的缓存区间最大值是可以动态配置的。

那么对于 Byte、Short、Long 是否也是一样的呢？答案是否定的，也就是说，如果上面程序的类型改成 Byte、Short、Long 任意一种，其输出结果只会有一种，也就是对应 Integer 的第一种结果，下面来具体分析各个类的内部缓存类的源码实现，在分析完后，或许就有了不一样的理解和认识。

1、Byte 的内部缓存类 ByteCache

private static class ByteCache {
    private ByteCache(){}

    // 定义了一个大小为 256 的 Byte[] 数组缓存
    static final Byte cache[] = new Byte[-(-128) + 127 + 1];

    // 静态代码块用于初始化 Byte[] 数组缓存
    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte)(i - 128));
    }
}

ByteCache 为 Byte 的内部静态类，由于构造函数为私有的，所以不能被实例化，缓存类中只有一个成员变量 cache，它是一个大小为 256 的 Byte 数组，静态代码块初始化时，会向数组中填充 256个 Byte 对象，这些 Byte 对象对应的数值是 [-128, 127]，下面再来看看 Byte 类 valueOf() 方法的实现。

public static Byte valueOf(byte b) {
    // 偏移量为 128
    final int offset = 128;
    // 这里直接从 ByteCache 的缓存数组中获取 Byte 对象
    return ByteCache.cache[(int)b + offset];
}

public static Byte valueOf(String s, int radix)
    throws NumberFormatException {
    // 调用的还是上面的方法
    return valueOf(parseByte(s, radix));
}

public static Byte valueOf(String s) throws NumberFormatException {
    return valueOf(s, 10);
}

虽然 Byte 类提供了3个 valueOf() 方法，但是通过分析可知，最终调用的都是第一个方法，即 valueOf(byte b) 这个，由于 byte 能表示的数值区间为 [-128, 127] ，所以如果是直接通过同一数值定义多个 Byte ，这些 Byte 实例对象都是相同的，如下：

public static void main(String[] args) {
    Byte byte1 = 1;
    Byte byte2 = 1;
    Byte byte3 = 1;

    System.out.println(byte1 == byte2);
    System.out.println(byte2 == byte3);
}

输出的结果如下：

true
true

那么如果换一种方式定义 byte1、byte2、byte3，结果又会怎么样呢？

public static void main(String[] args) {
    Byte byte1 = new Byte("1");
    Byte byte2 = new Byte("1");
    Byte byte3 = new Byte("1");
    
    System.out.println(byte1 == byte2);
    System.out.println(byte2 == byte3);
}

运行程序输出结果如下：

false
false

因为当直接使用 new 关键字创建对象时，会直接在堆上分配新的内存空间，同时 new Byte("1") 的实现和 valueOf() 并不一样，所以创建的 byte1、byte2、byte3 对象并不相同。

2、Short 的内部缓存类 ShortCache

private static class ShortCache {
    private ShortCache(){}

    // 定义了一个大小为 256 的 Short[] 数组缓存
    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 缓存类和 ByteCache 缓存类很类似，缓存数值的大小都是 256，缓存数值区间都是 [-128, 127]，只是数值的类型不一样，下面再来看看 Short 类的 valueOf() 方法实现。

public static Short valueOf(short s) {
    final int offset = 128;
    int sAsInt = s;
    // 如果 s 值在 [-128, 127] 之间，则直接返回 ShortCache.cache[] 中已缓存的对象
    if (sAsInt >= -128 && sAsInt <= 127) { // must cache
        return ShortCache.cache[sAsInt + offset];
    }
    
    // 不在 [-128, 127] 之间时，直接使用 new Short() 创建对象
    return new Short(s);
}

public static Short valueOf(String s) throws NumberFormatException {
    return valueOf(s, 10);
}

public static Short valueOf(String s, int radix)
    throws NumberFormatException {
    return valueOf(parseShort(s, radix));
}

和 Byte 类一样，Short 类也有3个 valueOf() 方法，只是 Short 类的 valueOf() 方法实现却不相同，主要由于 Short 类能表示的数值区间为 [-32768, 32767]，而 ShortCache 缓存的数值区间只有 [-128, 127]，所以只有当数值在 [-128, 127] 之间时，才能从缓存中复用对象，超过这些数值的，缓存中也没有。

3、Long 的内部缓存类 LongCache

private static class LongCache {
    private LongCache(){}

    // 定义了一个大小为 256 的 Long[] 数组缓存
    static final Long cache[] = new Long[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Long(i - 128);
    }
}

LongCache 的实现和 ShortCache 、ByteCache 并无区别，只是类型不一样而已，下面来看看其 valeuOf() 的实现

public static Long valueOf(long l) {
    final int offset = 128;
    // 如果 l 值在 [-128, 127] 之间，则直接返回 LongCache.cache[] 中已缓存的对象
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

public static Long valueOf(String s) throws NumberFormatException {
    return Long.valueOf(parseLong(s, 10));
}

public static Long valueOf(String s, int radix) throws NumberFormatException {
    return Long.valueOf(parseLong(s, radix));
}

可以看出，Long 类的 valueOf() 方法和 Short 类的 valueOf() 方法是一样的。

4、Integer 的内部缓存类 IntegerCache

之所以把 IntegerCache 放在最后分析，是因为 IntegerCache 的实现和其他的都不太一样，具体源码如下：

private static class IntegerCache {
    // 最小值 -128
    static final int low = -128;
    // 最大值
    static final int high;
    // 缓存数组
    static final Integer cache[];

    static {
        // 最大值默认为 127，也可以通过属性字段配置，具体属性名为 java.lang.Integer.IntegerCache.high
        int h = 127;
        // 获取 java.lang.Integer.IntegerCache.high 属性值
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        // 如果属性值不为空
        if (integerCacheHighPropValue != null) {
            try {
                // 使用 parseInt() 方法将属性值转换为 int 类型
                int i = parseInt(integerCacheHighPropValue);
                // 取属性值与127两者之间的最大值，也就是说 i 的最小值其实是127
                i = Math.max(i, 127);
                // 数组的最大值为 Integer.MAX_VALUE
                // 取 i 和 Integer.MAX_VALUE - (-low) -1 两者之间最小值
                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;

        // 创建大小为 (high - low) + 1 的整型数组
        cache = new Integer[(high - low) + 1];
        int j = low;
        // 创建并缓存 Integer 对象
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        // 断言缓存最大值 high 大于等于 127
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

结合上面已经分析的 ByteCache 和 ShortCache ，可以看出 IntegerCache 缓存类是有明显区别的，实现代码更多，从 IntegerCache 的定义可以看出，3个成员变量都是静态常量，只有一个静态代码块，没有任何其他的方法，关于静态代码块的分析已经在代码中备注了，从静态代码块中可以得出以下的几点：

IntegerCache 的缓存最小值 low 为 -128，与其他的类 Byte、Short、Long 是相同的；
IntegerCache 的缓存最大值 high 可以通过属性 java.lang.Integer.IntegerCache.high 进行设置，而其他的类 Byte、Short、Long 都是无法设置的；
IntegerCache 的缓存最大值 high 的最小值为127，如果通过属性设置的值比127小，则赋值为 127，也就是此时的属性值是无效的；

上面提到 IntegerCache 的缓存最大值 high 可以通过属性 java.lang.Integer.IntegerCache.high 进行设置，那么又该如何配置呢？这里以 Intellij IDEA 进行举例说明，首先找到测试类的配置，然后在 VM Options 参数一栏添加 -Djava.lang.Integer.IntegerCache.high=200 即可，如下：

Byte、Short、Integer、Long内部缓存类的对比与源码分析_缓存数组

此处将 java.lang.Integer.IntegerCache.high 设置为 200，再次运行下面的程序

public static void main(String[] args) {
    Integer num1 = 100;
    Integer num2 = 100;
    System.out.println("num1 与 num2 是否相等：" + (num1 == num2));

    Integer num3 = 128;
    Integer num4 = 128;
    System.out.println("num3 与 num4 是否相等：" + (num3 == num4));
}

输出的结果如下：

num1 与 num2 是否相等：true
num3 与 num4 是否相等：true

重要提示：

在上面的示例代码中，都是直接使用 == 进行比较，主要是为了验证对象是否为同一个，但是在实际的应用中，可能需要比较的是数值是否一样，这个时候如果直接使用 == 比较，可能会出现预期之外的值，具体原因上面也分析过，所以实际开发过程中，不建议直接使用 == 对包装类进行比较，而是使用 equals 进行比较。

5、Float 与 Double

分析到此处，可能有人会问，基本的数据类型中还有 float 和 double 类型，它们也有包装类 Float 和 Double ，是不是它们也有内部缓存类呢？答案是否定的， Float 和 Double 类中是没有内部缓存类的，也就是说不会存在对象复用，比如下面的代码：

public static void main(String[] args) {
    Float num1 = 1F;
    Float num2 = 1F;

    System.out.println(num1 == num2);

    Double num3 = 1D;
    Double num4 = 1D;

    System.out.println(num3 == num4);
}

运行程序，输出结果如下：

false
false

2赞
1收藏
评论
分享
举报

上一篇：Java 8中Collectors.groupingBy方法空指针异常源码分析

Byte、Short、Integer、Long内部缓存类的对比与源码分析

Byte、Short、Integer、Long内部缓存类的对比与源码分析

1、Byte 的内部缓存类 ByteCache

2、Short 的内部缓存类 ShortCache

3、Long 的内部缓存类 LongCache

4、Integer 的内部缓存类 IntegerCache

5、Float 与 Double

Recommend

iPadOS 16 may be delayed until new iPads ship

世卫组织呼吁停止使用电饭锅？电饭锅会致癌？央视实验告诉你答案

iPadOS 16 delay

Brew install Redis on Mac

Turn on Google Wallet’s ‘Personalization’ setting for proactive suggestions

SONDORS prepping its low-cost electric motorcycle for delivery [Update: Deliveri...

Riverdale: 22 Crazy Things That Absolutely Happened on the Show

科学家发现低温有助减肥网友：热胀冷缩

Every Samsung Galaxy S Release In Chronological Order

JUC（1）线程和进程、并发和并行、线程的状态、lock锁、生产者和消费者问题

About Joyk