Java整数缓存

先决条件： Java内部类 | Java中的原始数据类型 | Java中的自动装箱

Java不仅是一种语言，而且还是一种技术。 Java有明确定义的标准。在本文中，我们将讨论整数缓存。这个特性是在Java 5 中引入的，目的是改进内存管理。让我们首先看一个示例代码以更好地理解这种行为。之后，我们将讨论为什么要实现这一点。

在下面给出的程序中，您将清楚地理解逻辑，您将看到如何初始化变量 a 和 b 以及Java如何在整数缓存中保存变量值。之后，您将看到 -128 到 127 范围内的实例如何。此整数缓存仅适用于自动装箱，这意味着从原始类型到对象引用的转换称为自动装箱。

让我们考虑下面给出的Java代码的示例输出：

例子：

Java

import java.io.*;
 
class GFG {
   
    public static void main(String[] args)
    {
 
        // Initializing variable a and b.
        // Java keeps a integer cache of integer
        // instances in range of -128 to 127.
        // Integer Cache works only on autoboxing.
        // Conversion from primitive type to object
        // reference is called autoboxing.
 
        // In range declaration (-128 to 127) then
        // object reference will be same.
        Integer a = 9;
        Integer b = 9;
 
        // Then it will be true because both value of
        // a and b will point to the same object reference.
        if (a == b)
        {
            System.out.println("a==b");
        }
        else {
            System.out.println("a!=b");
        }
 
        // Not in range declaration (-128 to 127) then
        // then object reference will not be same in this
        // case.
        Integer x = 396;
        Integer y = 396;
 
        // Then it will be false because both value of
        // a and b will point to the different different
        // memory location.
        if (x == y) {
            System.out.println("x==y");
        }
        else
        {
          System.out.println("x!=y");
        }
    }
}

输出 ：

a==b
x!=y

在这里，我们预计两者都应该运行 if 条件部分。因为我们都知道在Java中 == 比较引用和 equals() 比较数据。但在这种情况下，行为并不像预期的那样。我们已经看到输出是意外的。

Java整数缓存实现：

在Java 5 中，引入了一项新功能来节省内存并提高处理 Integer 类型对象的性能。整数对象在内部缓存并通过相同的引用对象重用。

• 这适用于 –128 到 +127 范围内的整数值。
• 此整数缓存仅适用于自动装箱。整数对象在使用构造函数构建时不会被缓存。

自动装箱：

这相当于使用 valueOf() 如下：

Integer a=10; // this is autoboxing
Integer b==new Integer(40); // under the hood

IntegerCache 类：

IntegerCache 是Java的私有、静态和内部类。由于Java维护标准，这也有很好的文档记录并提供完整的信息。下面给出的是 IntegerCache 的内部实现。现在，您将在Java中看到 IntegerCache 的内部实现逻辑。

在下面给出的程序 var0、var1、var2、var3 和 high 中，检查 IntegerCache 的值的范围，通过检查您还可以看到 IntegerCache 的范围值，这样 class 用于缓存 -128 之间的值和 127。

当您检查任何对象引用值时，它将为您提供帮助。如果值将在范围声明中，则两个值的对象引用将相同，如果不在范围声明中，则对象引用将不同。因此，如果您将比较值，即使它相同并且可能是偶然的并且您已经取出了超出范围的值，那么在这种情况下，两个值即使相同但会返回 false 意味着它不相等，因为对于两个值对象引用会有所不同。

Java

// A program demonstrate IntegerCache
// implementation in Java.
 
// This is how IntegerCache class works.
private static class IntegerCache {
 
     // Method and variable declaration.
    static final int low = -128;
    static final int high;
    static final Integer[] cache;
    private IntegerCache() {}
 
    static
    {
        // Range value from -128 to 127
        int var0 = 127;
        String var1 = VM.getSavedProperty(
            "java.lang.Integer.IntegerCache.high");
        int var2;
        
       // Check if var1 value is null or not.
        if (var1 != null) {
            
          // For exception case
           try {
                var2 = Integer.parseInt(var1);
                var2 = Math.max(var2, 127);
                var0 = Math.min(var2, 2147483518);
            }
            catch (NumberFormatException var4) {
            }
        }
 
        high = var0;
        
       // High range for IntegerCache
        cache = new Integer[high - -128 + 1];
        var2 = -128;
       
       // defining var3 values using loop.
        for (int var3 = 0; var3 < cache.length; ++var3) {
            cache[var3] = new Integer(var2++);
        }
        assert high >= 127;
    }
}

以上 IntegerCache 类的说明：

• 代码明确指出该类用于缓存 -128 到 127 之间的值。可以使用参数 -XX: AutoBoxCacheMax=size 修改 127 的高值。

特征 ：

• 它使您可以根据我们的应用程序用例灵活地调整性能。
• 它为您提供了从 –128 到 127 之间选择数字的特定范围。
• 整数缓存使您可以缓存其他对象，例如 Byte、Short、Long 等。