What are primitive types vs reference types in Java?

Question

Accepted Answer

Java has two fundamental categories of types: **primitives** (simple values stored directly) and **reference types** (objects, where the variable holds a reference/pointer to the object). They behave very differently in memory, assignment, and comparison. ## The 8 primitive types ```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 ``` Primitives store the **actual value** directly, are fixed-size, can't be null, and live on the stack (for locals). They're fast and memory-efficient. ## Reference types — objects ```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 ``` Reference variables hold a **reference** (memory address) to an object stored on the heap — not the object itself. They can be `null`. ## The critical difference: assignment and comparison ```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 ``` This is a major gotcha: **`==` on objects compares identity (same object?), not content** — use `.equals()` for content comparison. ## Wrapper classes bridge the two ```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 ``` Each primitive has a wrapper class (`int`→`Integer`, etc.) so primitives can be used where objects are required (collections, generics). ## Why it matters The primitive-vs-reference distinction is fundamental to Java and the source of many subtle bugs and behaviors: assignment copies values for primitives but shares references for objects (so modifying a shared object affects all references), and especially that **`==` compares identity for objects** (a classic mistake — use `.equals()` for content). Understanding this affects correctness in comparisons, method arguments (objects are effectively passed by reference value), null-handling (only references can be null), and performance (primitives are lighter). It's core knowledge for writing correct Java.