Clases contenedoras en Java

¡Hola! Ya conoce bien los tipos primitivos y ha trabajado bastante con ellos. En programación (y Java en particular), las primitivas tienen muchas ventajas: usan poca memoria (y por lo tanto hacen que el programa sea más eficiente) y tienen un rango de valores claramente delineado. Sin embargo, mientras aprendemos Java, ya hemos repetido a menudo el mantra "todo en Java es un objeto". Pero los primitivos contradicen directamente esas palabras. No son objetos. Entonces, ¿es falso nuestro principio de "todo es un objeto"? En realidad, no lo es. En Java, cada tipo primitivo tiene un hermano gemelo, una clase contenedora.

¿Qué es una clase contenedora?

Un contenedor es una clase especial que almacena una primitiva internamente. Pero debido a que es una clase, puede crear instancias de ella. Almacenan los valores primitivos internamente, pero siguen siendo objetos reales. Los nombres de las clases contenedoras son muy similares (o exactamente iguales) a los nombres de sus primitivos correspondientes. Por lo tanto, son fáciles de recordar. Los objetos contenedor se crean de la misma manera que cualquier otro objeto:

public static void main(String[] args) {

   Integer i = new Integer(682);
  
   Double d = new Double(2.33);
  
   Boolean b = new Boolean(false);
}

Las clases contenedoras nos permiten mitigar las deficiencias de los tipos primitivos. La más obvia es que las primitivas no tienen métodos. Por ejemplo, no tienen un método toString() , por lo que no puede, por ejemplo, convertir un int en un String . Pero la clase contenedora Integer lo hace fácil.

public static void main(String[] args) {

   Integer i = new Integer(432);
  
   String s = i.toString();
}

Sin embargo, convertir en la otra dirección puede ser más complicado. Digamos que tenemos un String , que sabemos con seguridad que contiene un número. Independientemente, no hay una forma nativa de usar un int primitivo para extraer el número de String y convertirlo en un número. Pero, podemos hacerlo con las clases contenedoras.

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

Producción:

1166628

Extrajimos con éxito un número de String y lo asignamos a la variable de referencia Integer i . Por cierto, en cuanto a las referencias. Ya sabes que los argumentos se pasan a los métodos de diferentes maneras: primitivas por valor y objetos por referencia. Puede usar este conocimiento al crear sus propios métodos: por ejemplo, si su método usa números fraccionarios pero necesita lógica para pasar por referencia, puede pasar argumentos Double / Float al método en lugar de double / float . Además de los métodos de las clases contenedoras, sus campos estáticos también pueden ser muy convenientes. Por ejemplo, imagina que tienes la siguiente tarea: mostrar el máximo posiblevalor int , seguido del valor mínimo posible. Este problema parece bastante básico. Pero sin Google, es poco probable que puedas hacerlo. Pero los envoltorios le permiten manejar fácilmente tales "tareas mundanas":

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

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

Estos campos evitan que te distraigas de realizar tareas más serias. ¡Sin mencionar el hecho de que escribir 2147483647 (que resulta ser el valor de MAX_VALUE) no es una hazaña menor! :) Además, en una lección anterior, señalamos que los objetos de envoltorio son inmutables.

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

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

Producción:

0

El estado del objeto señalado originalmente por a no cambió (porque el valor de b también habría cambiado). Al igual que con String s, en lugar de cambiar el estado del objeto contenedor, se crea un objeto completamente nuevo en la memoria. Entonces, ¿por qué los creadores de Java finalmente decidieron dejar los tipos primitivos en el lenguaje? Ya que todo debería ser un objeto, y tenemos clases contenedoras que pueden expresar todo lo que expresan las primitivas, ¿por qué no mantener las envolturas en el lenguaje y eliminar las primitivas? La respuesta es simple: rendimiento. Los tipos primitivos se denominan primitivos porque carecen de muchas de las características de "peso pesado" de los objetos. Sí, los objetos tienen muchos métodos convenientes, pero no siempre los necesitas. A veces, todo lo que necesitas es el número 33, o 2,62, o verdadero / falso . En situaciones donde las ventajas de los objetos no importan y no son necesarias para que el programa funcione, las primitivas se adaptan mucho mejor a la tarea.