Quali sono i tipi primitivi rispetto ai tipi di riferimento in Java?

Question

Accepted Answer

Java ha due categorie fondamentali di tipi: **primitivi** (valori semplici archiviati direttamente) e **tipi di riferimento** (oggetti, dove la variabile contiene un riferimento/puntatore all'oggetto). Si comportano molto diversamente in memoria, assegnamento e confronto. ## Gli 8 tipi primitivi ```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 ``` I primitivi memorizzano il **valore effettivo** direttamente, hanno dimensione fissa, non possono essere null, e risiedono nello stack (per le variabili locali). Sono veloci e efficienti in termini di memoria. ## Tipi di riferimento — oggetti ```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 ``` Le variabili di riferimento contengono un **riferimento** (indirizzo di memoria) a un oggetto memorizzato nell'heap — non l'oggetto stesso. Possono essere `null`. ## La differenza critica: assegnamento e confronto ```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 ``` Questo è un errore comune: **`==` sugli oggetti confronta l'identità (stesso oggetto?), non il contenuto** — usa `.equals()` per il confronto del contenuto. ## Le classi wrapper collegano i due ```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 ``` Ogni primitivo ha una classe wrapper (`int`→`Integer`, ecc.) così i primitivi possono essere usati dove sono richiesti oggetti (collezioni, generici). ## Perché è importante La distinzione primitivo-vs-riferimento è fondamentale per Java ed è la fonte di molti bug e comportamenti sottili: l'assegnamento copia i valori per i primitivi ma condivide i riferimenti per gli oggetti (quindi modificare un oggetto condiviso influisce su tutti i riferimenti), e soprattutto che **`==` confronta l'identità per gli oggetti** (un errore classico — usa `.equals()` per il contenuto). Capire questo influisce sulla correttezza nei confronti, negli argomenti dei metodi (gli oggetti sono effettivamente passati per valore di riferimento), nella gestione dei null (solo i riferimenti possono essere null), e nella performance (i primitivi sono più leggeri). È conoscenza fondamentale per scrivere Java corretto.