Clase contenedora de Java

Clase contenedora de Java

En este tutorial, aprenderemos sobre la clase Java Wrapper con la ayuda de ejemplos.

Las clases contenedoras en Java se utilizan para convertir tipos primitivos (int , char , float , etc) en los objetos correspondientes.

Cada uno de los 8 tipos primitivos tiene clases contenedoras correspondientes.

Convertir Tipo Primitivo a Objetos Contenedores

También podemos usar el valueOf() método para convertir tipos primitivos en objetos correspondientes.

Ejemplo 1:Tipos primitivos para envolver objetos

class Main {
  public static void main(String[] args) {

    // create primitive types
    int a = 5;
    double b = 5.65;

    //converts into wrapper objects
    Integer aObj = Integer.valueOf(a);
    Double bObj = Double.valueOf(b);

    if(aObj instanceof Integer) {
      System.out.println("An object of Integer is created.");
    }

    if(bObj instanceof Double) {
      System.out.println("An object of Double is created.");
    }
  }
}

Salida

An object of Integer is created.
An object of Double is created.

En el ejemplo anterior, hemos utilizado el valueOf() método para convertir los tipos primitivos en objetos.

Aquí, hemos utilizado el instanceof operador para verificar si los objetos generados son de Integer o Double tipo o no.

Sin embargo, el compilador de Java puede convertir directamente los tipos primitivos en los objetos correspondientes. Por ejemplo,

int a = 5;
// converts into object
Integer aObj = a;

double b = 5.6;
// converts into object
Double bObj = b;

Este proceso se conoce como boxeo automático. . Para obtener más información, visite Autoboxing y unboxing de Java.

Nota :También podemos convertir tipos primitivos en objetos contenedor usando Wrapper constructores de clases. Pero el uso de constructores se descarta después de Java 9.

Objetos Wrapper en Tipos Primitivos

Para convertir objetos en tipos primitivos, podemos usar los métodos de valor correspondientes (intValue() , doubleValue() , etc) presentes en cada clase contenedora.

Ejemplo 2:Objetos envoltorios en tipos primitivos

class Main {
  public static void main(String[] args) {

    // creates objects of wrapper class
    Integer aObj = Integer.valueOf(23);
    Double bObj = Double.valueOf(5.55);

    // converts into primitive types
    int a = aObj.intValue();
    double b = bObj.doubleValue();

    System.out.println("The value of a: " + a);
    System.out.println("The value of b: " + b);
  }
}

Salida

The value of a: 23
The value of b: 5.55

En el ejemplo anterior, hemos utilizado el intValue() y doubleValue() método para convertir el Integer y Double objetos en tipos primitivos correspondientes.

Sin embargo, el compilador de Java puede convertir automáticamente objetos en tipos primitivos correspondientes. Por ejemplo,

Integer aObj = Integer.valueOf(2);
// converts into int type
int a = aObj;

Double bObj = Double.valueOf(5.55);
// converts into double type
double b = bObj;

Este proceso se conoce como unboxing . Para obtener más información, visite Autoboxing y unboxing de Java.

Ventajas de las Clases Wrapper

• En Java, a veces es posible que necesitemos usar objetos en lugar de tipos de datos primitivos. Por ejemplo, al trabajar con colecciones.

  // error
  ArrayList<int> list = new ArrayList<>();
  
  // runs perfectly
  ArrayList<Integer> list = new ArrayList<>();

  En tales casos, las clases contenedoras nos ayudan a usar tipos de datos primitivos como objetos.
• Podemos almacenar el valor nulo en objetos contenedor. Por ejemplo,

  
  // generates an error
  int a = null;
  
  // runs perfectly
  Integer a = null;
  

Nota :Los tipos primitivos son más eficientes que los objetos correspondientes. Por lo tanto, cuando la eficiencia es el requisito, siempre se recomiendan los tipos primitivos.