Caché de enteros de Java

Prerrequisito: Clase Interna de Java | Tipo de datos primitivo en Java | Autoboxing en Java

Java no es solo un lenguaje sino una tecnología. Java tiene estándares bien definidos. En este artículo, discutiremos la caché de enteros. Esta función se introdujo en Java 5 para mejorar la gestión de la memoria. Primero echemos un vistazo a un código de muestra para comprender mejor este comportamiento. Después, discutiremos por qué se implementa esto.

En el programa a continuación, comprenderá claramente la lógica y verá cómo ha inicializado las variables a y b y cómo Java mantiene el valor de la variable en la caché de enteros. Después de eso, verá cómo instancias en el rango de -128 a 127. Esta caché de enteros solo funciona en autoboxing, lo que significa que la conversión de un tipo primitivo a una referencia de objeto se llama autoboxing.

Consideremos una salida de ejemplo del código Java que se muestra a continuación:

Ejemplo:

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
        // memory location.
        if (x == y) {
            System.out.println("x==y");
        }
        else
        {
          System.out.println("x!=y");
        }
    }
}

Producción :

a==b
x!=y

Aquí esperábamos que ambos se ejecutaran si parte de la condición. Porque todos sabemos que == compare referencia y equals() compare datos en java. Pero en este caso, el comportamiento no es el esperado. Habíamos visto que la salida es inesperada.

Implementación de caché de enteros de Java:

En Java 5, se introdujo una nueva característica para ahorrar memoria y mejorar el rendimiento para el manejo de objetos de tipo Integer. Los objetos enteros se almacenan en caché internamente y se reutilizan a través de los mismos objetos a los que se hace referencia.

• Esto es aplicable para valores enteros en el rango entre –128 y +127.
• Este almacenamiento en caché de enteros solo funciona en el encuadre automático. Los objetos enteros no se almacenarán en caché cuando se construyan con el constructor.

Autoboxeo:  

Esto es igual a usar valueOf() de la siguiente manera: 

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

Clase IntegerCache:

IntegerCache es una clase privada, estática e interna de Java. Como Java mantiene estándares y esto también está muy bien documentado y brinda información completa. A continuación se muestra la implementación interna de IntegerCache. Ahora, verá la lógica de implementación interna para IntegerCache en Java.

En el programa dado a continuación, var0, var1, var2, var3 y alto para el rango para verificar los valores de IntegerCache, y al verificar también puede ver los valores de rango para IntegerCache, de modo que la clase es para un caché de valores entre -128 y 127. 

Le ayudará cuando verifique los valores de referencia de cualquier objeto. Y si el valor estará en la declaración del rango, la referencia del objeto para ambos valores será la misma y si no está en la declaración del rango, la referencia del objeto será diferente. Entonces, si comparará valores incluso si es el mismo y podría ser casualidad y ha sacado valores fuera del rango, entonces, en ese caso, ambos valores, incluso si será el mismo pero devolverá falso significa que no es igual porque para ambos valores la referencia del objeto será diferente.

// 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;
    }
}

 
Explicación de la clase IntegerCache anterior:  

• El código establece claramente que la clase es para un caché de valores entre -128 y 127. El valor alto de 127 se puede modificar usando un argumento -XX: AutoBoxCacheMax=size.

Características : 

• Le brinda la flexibilidad de ajustar el rendimiento de acuerdo con el caso de uso de nuestra aplicación.
• Le brinda un rango específico para elegir números de -128 a 127.
• El caché de enteros le brinda la posibilidad de almacenar en caché otros objetos también, por ejemplo, como Byte, Short, Long, etc.