Internado de String en Java

String Interning es un método para almacenar solo una copia de cada valor de string distinto, que debe ser inmutable.
Al aplicar String.intern() en un par de strings, se asegurará de que todas las strings que tengan el mismo contenido compartan la misma memoria. Por ejemplo, si el nombre ‘Amy’ aparece 100 veces, al internar se asegura de que solo se asigne memoria a una ‘Amy’.

Esto puede ser muy útil para reducir los requisitos de memoria de su programa. Pero tenga en cuenta que JVM mantiene la memoria caché en un grupo de memoria permanente, que generalmente tiene un tamaño limitado en comparación con el montón, por lo que no debe usar interno si no tiene demasiados valores duplicados.

Método intern(): en Java, cuando realizamos cualquier operación usando el método intern(), devuelve una representación canónica para el objeto de string. Un grupo es administrado por la clase String.

• Cuando se ejecuta el método interno(), verifica si la string es igual a este objeto de string en el grupo o no.
• Si está disponible, se devuelve la string del grupo. De lo contrario, este objeto String se agrega al grupo y se devuelve una referencia a este objeto String.
• De ello se deduce que para cualesquiera dos strings s y t, s.intern() == t.intern() es verdadero si y solo si s.equals(t) es verdadero.

Se recomienda usar equals(), no ==, para comparar dos strings. Esto se debe a que el operador == compara ubicaciones de memoria, mientras que el método equals() compara el contenido almacenado en dos objetos.

// Java program to illustrate 
// intern() method 
class GFG { 
    public static void main(String[] args) 
    { 
        // S1 refers to Object in the Heap Area 
        String s1 = new String("GFG"); // Line-1 
  
        // S2 refers to Object in SCP Area
        String s2 = s1.intern(); // Line-2 
          
        // Comparing memory locations
        // s1 is in Heap
        // s2 is in SCP
        System.out.println(s1 == s2);
          
        // Comparing only values
        System.out.println(s1.equals(s2));
          
        // S3 refers to Object in the SCP Area 
        String s3 = "GFG"; // Line-3 
  
        System.out.println(s2 == s3); 
    } 
} 

Producción:

false
true
true

Explicación: cada vez que creamos un objeto de string, se crearán dos objetos, es decir, uno en el área de montón y otro en el grupo de constantes de string y la referencia del objeto de string siempre apunta al objeto del área de montón. Cuando se ejecute la línea 1, creará dos objetos y apuntará al objeto creado en el área del montón. Ahora, cuando se ejecuta la línea 2, se referirá al objeto que está en el SCP. Nuevamente, cuando se ejecuta la línea 3, se refiere al mismo objeto que está en el área SCP porque el contenido ya está disponible en el área SCP. No es necesario crear un nuevo objeto.

Si el objeto del conjunto de constantes de string (SCP) correspondiente no está disponible, el método intern() creará el objeto SCP correspondiente.

// Java program to illustrate 
// intern() method 
class GFG { 
    public static void main(String[] args) 
    { 
        // S1 refers to Object in the Heap Area 
        String s1 = new String("GFG"); // Line-1 
  
        // S2 now refers to Object in SCP Area 
        String s2 = s1.concat("GFG"); // Line-2 
  
        // S3 refers to Object in SCP Area
        String s3 = s2.intern(); // Line-3 
  
        System.out.println(s2 == s3); 
  
        // S4 refers to Object in the SCP Area 
        String s4 = "GFGGFG"; // Line-4 
  
        System.out.println(s3 == s4); 
    } 
} 

Producción:

true
true

Explicación: usamos el método interno() para obtener la referencia del objeto SCP correspondiente. En este caso, cuando Line-2 ejecuta s2 tendrá el valor «GFGGFG» en él solo crea un objeto. En Line-3, tratamos de internar s3, que nuevamente está con s2 en el área SCP. s4 también está en SCP, por lo que todos dan resultados como verdaderos cuando se comparan.