¿Cuáles son los tipos primitivos versus los tipos de referencia en Java?

Question

Accepted Answer

Java tiene dos categorías fundamentales de tipos: **primitivos** (valores simples almacenados directamente) y **tipos de referencia** (objetos, donde la variable contiene una referencia/puntero al objeto). Se comportan muy diferente en la memoria, la asignación y la comparación. ## Los 8 tipos primitivos ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Los primitivos almacenan el **valor actual** directamente, tienen tamaño fijo, no pueden ser null, y viven en la pila (para variables locales). Son rápidos y eficientes en memoria. ## Tipos de referencia — objetos ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` Las variables de referencia contienen una **referencia** (dirección de memoria) a un objeto almacenado en el montón (heap) — no el objeto en sí. Pueden ser `null`. ## La diferencia crítica: asignación y comparación ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` Esta es una trampa importante: **`==` en objetos compara identidad (¿mismo objeto?), no contenido** — usa `.equals()` para comparar contenido. ## Las clases wrapper cierran la brecha ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` Cada tipo primitivo tiene una clase wrapper (`int`→`Integer`, etc.) para que los primitivos se puedan usar donde se requieren objetos (colecciones, genéricos). ## Por qué es importante La distinción primitivo-versus-referencia es fundamental en Java y fuente de muchos errores sutiles y comportamientos: la asignación copia valores para primitivos pero comparte referencias para objetos (así que modificar un objeto compartido afecta todas las referencias), y especialmente que **`==` compara identidad para objetos** (un error clásico — usa `.equals()` para contenido). Entender esto afecta la corrección en comparaciones, argumentos de método (los objetos se pasan efectivamente por valor de referencia), manejo de null (solo las referencias pueden ser null) y rendimiento (los primitivos son más ligeros). Es conocimiento esencial para escribir Java correcto.