Diferentes formas de crear instancias de clases contenedoras en Java

Wrapper Class una clase cuyo objeto envuelve o contiene tipos de datos primitivos. Cuando creamos un objeto para una clase contenedora, contiene un campo y en este campo podemos almacenar tipos de datos primitivos. En otras palabras, podemos envolver un valor primitivo en un objeto de clase contenedora.

Métodos:

Podemos usar dos formas de construir la instancia de las Clases Wrapper

1. Usando el constructor de la clase contenedora
2. Usando el método valueOf() provisto por las clases Wrapper
3. Usando el concepto de AutoBoxing

Discutamos ambas formas individualmente en detalle.

Método 1 : usar el constructor de la clase contenedora

Sintaxis:

ClassName object = new ClassName(argument);

Ilustración:

Integer number = new Integer(5);

Método 2: usar el método valueOf() proporcionado por las clases Wrapper

Sintaxis:

ClassName object = ClassName.valueOf(argument);

Ilustración:

Integer number = Integer.valueOf(5);

Ahora surge la pregunta cuál es la diferencia entre los dos métodos en la creación de instancias de las clases Wrapper y qué método es mejor para construir instancias. Implementemos ambos métodos para lograr un juego limpio entre ellos.

Implementación:

Ejemplo

// Importing input output classes
import java.io.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main (String[] args) {
 
        // Creating and initializing two integer numbers
        // Value is passed as an argument to which it is initialized
         
        // Custom entries 
        // Number 1 where N = 5
        Integer num1 = new Integer(5);
        // Number 2 where N = 5
        Integer num2 = new Integer(5);
         
        // Creating objects of Integer class
        // using valueOf() method
     
        // Again, creating and initializing two integer numbers
        // Value is passed as an argument to which it is initialized
        Integer num3 = Integer.valueOf(5);
        Integer num4 = Integer.valueOf(5);
         
 
        // Now by far, all the objects contain the same value
        // N = 5
         
        // Boolean will return true if numbers are equal
        // else returning false
 
        // Comparing two numbers 
        boolean value1 = (num1 == num2);
        boolean value2 = (num3 == num4);
         
        // Print and display the bool results
        System.out.println(value1);
        System.out.println(value2);
    }
}

Producción:

false
true

Explicación de salida:

Tenga en cuenta que las instancias de las clases apuntan a las ubicaciones de memoria asignadas en el montón y en sí mismas no contienen el valor. Mientras creamos objetos con la ayuda del constructor de la clase contenedora, cada vez que se asigna una nueva memoria en el montón y los objetos apuntan a las diferentes ubicaciones de memoria. Por lo tanto, en el ejemplo anterior, en este caso, tanto num1 como num2 apuntan a diferentes ubicaciones de memoria, por lo tanto, en la comparación, devuelven falso.

Tenga en cuenta que no es así en el caso del método valueOf() ya que el método valueOf() comprueba si alguna memoria está asignada al mismo valor para esa clase en el montón. Si encuentra el valor, proporciona la ubicación de la memoria previamente asignada a la nueva instancia y ambos comienzan a apuntar a la misma ubicación de memoria en el montón. Por lo tanto, en la comparación, devuelve verdadero.

Dado que los valores del objeto de la clase contenedora son inmutables al igual que String y, por lo tanto, no se pueden cambiar una vez asignados, no afecta la cantidad de instancias que apuntan a la misma ubicación de memoria. Por lo tanto, en el ejemplo anterior, la memoria se asignó al valor 5 y num3 apuntaba a esa ubicación de memoria, pero cuando creamos una instancia más num4 con el mismo valor, también comenzó a apuntar a la misma ubicación de memoria señalada por num3 .

Actualmente, el método que usa un constructor para crear una instancia está en desuso y, por lo tanto, siempre es mejor usar el método valueOf(). Así que avancemos un poco discutiendo el nuevo concepto de autoboxing.

Método 3: Usando el concepto de AutoBoxing

AutoBoxing es para reducir los esfuerzos para escribir el método valueOf() cada vez que estamos creando instancias, se implementa AutoBoxing. La conversión automática de tipos primitivos al objeto de sus correspondientes clases contenedoras se conoce como AutoBoxing.

Estábamos creando clases contenedoras hasta ahora usando el método valueOf() , pero parece bastante largo cuando podemos usar AutoBoxing. En AutoBoxing, nuestro trabajo lo realiza el compilador, es decir, el compilador de Java en segundo plano realizaría la operación valueOf() y crearía la instancia de la misma.

Las instancias creadas con autoboxing siguen el proceso de valueOf() en segundo plano y, por lo tanto, también en esto, varias instancias con el mismo valor apuntan a la misma ubicación de memoria.

Ilustración: En el ejemplo anterior, también se puede escribir como Integer.valueOf(15) ) y poner su referencia en el objeto (es decir, un número).

Integer number = 15;

Sintaxis:

ClassName object = value;                 
// of primitive data type associated with the wrapper class.

Ejemplo:

// Importing input output classes
import java.io.*;
 
// Main class
class GFG {
   
    // Main driver method
    public static void main (String[] args) {
         
      // Creating Instances using AutoBoxing
      Integer num1 = 5;
      Integer num2 = 5;
       
      boolean bool = (num1 == num2);
      System.out.println(bool);
    }
}

true

Explicación de salida:

Tanto el num1 como el num2 apuntan a la misma ubicación de memoria en el montón como discutimos en el método   valueOf() .