Vad är primitiva typer jämfört med referenstyper i Java?

Question

Accepted Answer

Java har två grundläggande kategorier av typer: **primitiva typer** (enkla värden lagrade direkt) och **referenstyper** (objekt, där variabeln innehåller en referens/pekare till objektet). De beter sig mycket olika i minnet, vid tilldelning och jämförelse. ## De 8 primitiva typerna ```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 ``` Primitiva typer lagrar det **faktiska värdet** direkt, är av fast storlek, kan inte vara null och bor på stacken (för lokala variabler). De är snabba och minneseffektiva. ## Referenstyper — objekt ```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 ``` Referensvariabler innehåller en **referens** (minnesadress) till ett objekt lagrat på heapen — inte själva objektet. De kan vara `null`. ## Den kritiska skillnaden: tilldelning och jämförelse ```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 ``` Detta är en stor fallgrop: **`==` på objekt jämför identitet (samma objekt?), inte innehål** — använd `.equals()` för innehållsjämförelse. ## Wrapper-klasser överbryggar de två ```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 ``` Varje primitiv typ har en wrapper-klass (`int`→`Integer`, etc.) så primitiva typer kan användas där objekt krävs (samlingar, generik). ## Varför det spelar roll Skillnaden mellan primitiva och referenstyper är fundamental för Java och källan till många subtila buggar och beteenden: tilldelning kopierar värden för primitiva typer men delar referenser för objekt (så ändring av ett delat objekt påverkar alla referenser), och särskilt att **`==` jämför identitet för objekt** (ett klassiskt misstag — använd `.equals()` för innehållsjämförelse). Förståelse av detta påverkar korrekthet vid jämförelser, metodargument (objekt skickas effektivt med referensvärde), null-hantering (bara referenser kan vara null) och prestanda (primitiva typer är lättare). Det är kärnkunskap för att skriva korrekt Java.