Tipos primitivos vs. Tipos primitivos empaquetados

• Tipos primitivos: int, double, boolean, etc.
• Tipos primitivos empaquetados: entero, doble, booleano, etc.
• Java tiene un sistema de tipos doble: tipos primitivos y tipos de referencia (objetos).
• Cada tipo primitivo tiene una clase contenedora correspondiente.

Diferencias principales

• Identidad vs. Valor:
  Primitivos: No tienen identidad; dos primitivas con el mismo valor siempre son iguales.
  Empaquetado: Son objetos y tienen una identidad; dos objetos pueden tener el mismo valor pero identidades diferentes.

• Valores nulos:
  Primitivas: Siempre tienen un valor predeterminado (por ejemplo, 0 para int).
  Empaquetado: Puede ser nulo, lo que puede generar excepciones NullPointerException si no se maneja correctamente.

• Actuación:
  Primitivas: Más eficientes en términos de tiempo y espacio.
  Empaquetado: Introduce gastos generales debido a la creación de objetos adicionales.

Problemas comunes al mezclar primitivas y paquetes

• 1. Comparación de identidad en lugar de valor
• Al comparar objetos empaquetados usando ==, estás comparando referencias de objetos, no los valores. Esto puede generar resultados inesperados.

Ejemplo problemático:

Comparator naturalOrder = (i, j) -> (i 



Problema: Comparación i == j compara referencias, no valores.

Comportamiento incorrecto: naturalOrder.compare(new Integer(42), new Integer(42)) devuelve 1 en lugar de 0.

Solución:

Utilice el método compareTo o los métodos de utilidad de la clase Integer.


Comparator naturalOrder = Integer::compare;





O, corrigiendo el comparador original:


Comparator naturalOrder = (iBoxed, jBoxed) -> {
    int i = iBoxed;
    int j = jBoxed;
    return (i 



2. Desembalaje automático y NullPointerException

Cuando se utilizan tipos empaquetados que pueden ser nulos, el desempaquetado automático puede generar excepciones si el objeto es nulo.

Ejemplo problemático:


Integer i = null;
if (i == 42) {
    System.out.println("Inacreditável");
}





Problema: i es nulo; al comparar con 42, se produce un desembalaje automático nulo, lo que genera NullPointerException.
Solución: Utilice tipos primitivos cuando sea posible.


int i = 0;
if (i == 42) {
    System.out.println("Inacreditável");
}





3. Rendimiento degradado debido al autoboxing/unboxing

El uso inadvertido de tipos ajustados en operaciones intensivas puede causar una degradación del rendimiento debido al autoboxing y la creación innecesaria de objetos.

Ejemplo problemático:


Long sum = 0L;
for (long i = 0; i 



Problema: sum es un Long empaquetado; en cada iteración, se produce el autoboxing/unboxing.

Impacto: código mucho más lento y uso excesivo de memoria.
Solución:

Utilice tipos primitivos para variables locales en operaciones intensivas.


long sum = 0L;
for (long i = 0; i 



Cuándo utilizar tipos empaquetados

Colecciones: no puedes usar tipos primitivos en colecciones genéricas (por ejemplo, Lista).
Parámetros genéricos: los tipos genéricos no admiten tipos primitivos (por ejemplo, ThreadLocal).
API que requieren objetos: ciertas API requieren objetos en lugar de tipos primitivos.
Buenas Prácticas

Prefiere tipos primitivos: siempre que sea posible, utiliza tipos primitivos para mayor simplicidad y eficiencia.
Cuidado con el autoboxing/unboxing: el autoboxing reduce la verbosidad pero puede introducir errores sutiles.
Evite comparaciones con == en empaquetado: utilice métodos como equals() o compare los valores no empaquetados.
Compruebe si hay valores nulos: cuando trabaje con tipos empaquetados, tenga en cuenta que pueden ser nulos y causar NullPointerException.
Resumen
Tipos primitivos:

Más simple y más rápido.

No pueden ser nulos.

No tienen identidad (solo valor).

Tipos empaquetados:

Requerido para su uso en colecciones y API genéricas.

Pueden ser nulos.

Tienen identidad de objeto.