Las clases contenedoras primitivas son inmutables en Java

En Java, una clase inmutable es una clase (Integer, Byte, Long, Float, Double, Character, Boolean y Short) que una vez creada, su cuerpo no se puede cambiar y lo mismo se aplica a los objetos inmutables que una vez creados no se pueden cambiar. . Ahora surge la pregunta de que necesitamos la ayuda de las clases contenedoras al tratar con tipos de datos primitivos en Java, donde estas clases se hacen inmutables. 

Geeks, ahora deben preguntarse por qué los hacemos inmutables, por lo que enumeraremos algunas ventajas que se enumeran a continuación:

• Se sincronizan automáticamente ya que su estado no puede ser alterado en virtud de la definición de inmutabilidad.
• No hay ámbitos de inconsistencia ya que un objeto de la clase contenedora no se puede modificar.
• Ayuda en el almacenamiento en caché, ya que una instancia de un tipo específico puede facilitar docenas de aplicaciones.

Sugerencia: el mejor uso de las clases contenedoras como objetos inmutables es como claves del mapa.  

Ejemplo:

// Java Program to Demonstrate that Primitive
// Wrapper Classes are Immutable
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Getting an integer value
        Integer i = new Integer(12);
 
        // Printing the same integer value
        System.out.println(i);
 
        // Calling method 2
        modify(i);
 
        // Now printing the value stored in above integer
        System.out.println(i);
    }
 
    // Method 2
    // To modify integer value
    private static void modify(Integer i) { i = i + 1; }
}

Producción:

Explicación de salida: 

Aquí, el parámetro ‘i’ es la referencia en la modificación y se refiere al mismo objeto que ‘i’ en main(), pero los cambios realizados en ‘i’ no se reflejan en el método main(). Es porque todas las clases contenedoras primitivas (Integer, Byte, Long, Float, Double, Character, Boolean y Short) son inmutables en Java, por lo que operaciones como la suma y la resta crean un nuevo objeto y no modifican el anterior. 
La siguiente línea de código en el método de modificación está operando en la clase contenedora Integer, no en un int, y hace lo siguiente como se describe a continuación:

i = i + 1;

• Unbox ‘i’ a un valor int
• Suma 1 a ese valor
• Encajone el resultado en otro objeto Integer
• Asigne el entero resultante a ‘i’ (cambiando así a qué objeto ‘i’ hace referencia)

Dado que las referencias a objetos se pasan por valor, la acción realizada en el método modificado no cambia i que se usó como argumento en la llamada a modificar. Por lo tanto, la rutina principal aún imprime 12 después de que el método regresa.

Este artículo es una contribución de Yogesh D Doshi . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.