Wrapper classes

1. Lista de tipos envolventes

Sabes que Java tiene 8 tipos primitivos, que son tipos que no son clases. Por un lado, esto es bueno: son simples y ocupan poco espacio. Por otro lado, a veces solo necesitamos clases. Descubrirás exactamente por qué en la próxima lección.

¿Entonces qué se puede hacer?

A partir de la quinta versión de Java, cada tipo primitivo obtuvo una clase complementaria. Cada una de estas clases almacena un solo campo con un valor de un tipo específico. Estas clases se llaman tipos envolventes, porque envuelven valores primitivos en clases.

Aquí tienes una lista de estos tipos. ¿Conoces alguno?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

Los nombres de los tipos primitivos comienzan con una letra minúscula, pero los nombres de las clases de envoltorio comienzan con una letra mayúscula. Algunos de los nombres de las clases también son un poco más largos: Integer en lugar de int y Character en lugar de char.

Todos los objetos de las clases de envoltorio son inmutables (immutable).

Un código simplificado para la clase Integer se parece a esto:

public class Integer
{
   private int value;

   Integer(int x)
   {
      this.value = x;
   }

   public int intValue()
   {
      return this.value;
   }

   public static Integer valueOf(int x)
   {
      return new Integer(x);
   }
}

2. Conversión de un int a un Integer

Los tipos de envoltura se consideran contrapartes de sus tipos primitivos: puedes crear fácilmente un objeto envolvente que corresponda a un tipo primitivo.

Usemos el tipo int como ejemplo para analizar cómo los tipos primitivos interactúan con sus tipos de envoltura correspondientes. El código para convertir de un int a un Integer y viceversa se vería así:

Para convertir un int a un Integer, necesitas escribir este código:

Integer name = new Integer(value);

Donde name es el nombre de una variable Integer, y value es el valor int envuelto.

Ejemplos:

Integer age = new Integer(18);

Integer hundred = new Integer(100);

Integer zero = new Integer(0);

Para convertir un Integer a un int, necesitas escribir este código:

int name = variable.intValue();

Donde name es el nombre de una variable de tipo int, y variable es una referencia a un objeto Integer.

Ejemplos:

Integer age = new Integer(18);
int x = age.intValue();

x == 18

Integer hundred = new Integer(100);
int y = hundred.intValue();

y == 100

Integer zero = new Integer(0);
int z = zero.intValue();

z == 0

int i = 110;
Integer zero = new Integer(i);
int z = zero.intValue();

z == 110

3. Autoboxing and unboxing

Sin embargo, incluso las operaciones simples con el tipo Integer no son fáciles de escribir.

Como dijimos anteriormente, el tipo Integer es inmutable. Para crear un objeto Integer con un nuevo valor int, es necesario crear explícitamente un nuevo objeto Integer. Dicho esto, es fácil obtener el valor de un int almacenado dentro de un objeto Integer - simplemente llame al método intValue().

Ejemplo:

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = new Integer(b + 5)

¿No te parece que este código es algo engorroso?

Los creadores de Java pensaron lo mismo, así que enseñaron al compilador a hacer estas operaciones automáticamente. La conversión automática de un int a un Integer se llama autoboxing (poner automáticamente el valor en una caja), y la operación inversa (convertir un Integer a un int) se llama unboxing.

Integer a = 10;

Integer a = Integer.valueOf(10);

int b = a;

int b = a.intValue();

Integer c = a + b;

Integer c = Integer.valueOf(a.intValue() + b);

Gracias al autoboxing y unboxing, puedes asignar de manera segura un int a una variable Integer y viceversa. Puedes escribir expresiones de cualquier complejidad sin hacer una distinción entre los tipos int e Integer.

Ejemplos:

Integer a = 5;
int b = a;
Integer c = a + b;
int d = a + b + c;

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = Integer.valueOf(a.intValue() + b);
int d = a.intValue() + b + c.intValue();

Integer a = 5;
int b = 5;

if (a == b)
{
   ...
}

Integer a = Integer.valueOf (5);
int b = 5;

if (a.intValue() == b)
{
   ...
}

4. Comparando variables envueltas

La autoboxing y unboxing son procesos simples y transparentes. Usamos las sentencias new Integer() según sea necesario y llamamos al método intValue() según sea necesario.

Todo funciona bien y fácil para ti, el programador. Pero ten en cuenta que si comparas un Integer y un Integer, la comparación se basa en la referencia y no en los valores.

Integer a = 1000;
Integer b = 1000;

System.out.println(a == b);

false

Integer a = 1000;
Integer b = 1000;

System.out.println(a.equals(b));

true

Las variables a y b no almacenan valores int. Almacenan referencias a objetos. Eso significa que es importante recordar cómo compararlos correctamente:

Integer a = 1000;
Integer b = 1000;
if (a == b)
{
   ...
}

Integer a = 1000;
Integer b = 1000;
if (a.equals(b))
{
   ...
}