Hur fungerar arrayer i Java?

Question

Accepted Answer

En **array** är en samling med **fast storlek** och ordnade element av **samma typ**, lagrade tillsammans i minnet. Arrayer är grundläggande, men deras fasta storlek innebär att du ofta föredrar `ArrayList` för dynamiska samlingar. ## Deklarera och skapa arrayer ```java int[] nums = new int[5]; // size 5, default-initialized to 0 int[] nums2 = {1, 2, 3, 4, 5}; // declare + initialize with values String[] names = new String[3]; // objects default to null nums[0] = 10; // set by index (0-based) int x = nums[0]; // get by index nums.length; // 5 — the size (a field, NOT a method!) ``` Arrayer har en **fast storlek** som sätts vid skapandet — du kan inte förstora eller förminska dem. Element får typlämpliga standardvärden (`0`, `0.0`, `false`, `null`). ## En vanlig fallgrop: length är ett fält ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Array `length` är ett fält; String `length()` och collection `size()` är metoder — en vanlig förvirringspunkt. ## Gränskontroll ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` Java kastar ett undantag för åtkomst utanför gränser (till skillnad från C, som har odefinierat beteende) — säkrare, men du måste hålla dig inom `0` till `length-1`. ## Iterering ```java // enhanced for-each (when you don't need the index) for (int n : nums) { System.out.println(n); } // traditional for (when you need the index) for (int i = 0; i < nums.length; i++) { nums[i] *= 2; } ``` ## Flerdimensionella arrayer ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Arrayer mot ArrayList — när du använder vilken ```text Array → fixed size, slightly faster, can hold primitives directly (int[]) ArrayList → DYNAMIC size (grow/shrink), rich methods (add/remove/contains), but holds objects only (Integer, not int) ``` ```java List list = new ArrayList<>(); list.add(1); // grows dynamically — no fixed size list.remove(0); ``` Använd en vanlig array för fast storlek, prestandakänsliga eller primitiva data; använd `ArrayList` när storleken ändras eller du behöver praktiska operationer. ## Varför det är viktigt Arrayer är en grundläggande datastruktur i Java — snabb, minneseffektiv lagring i sammanhängande minne som används direkt och som grund för många samlingar (ArrayList omsluter en array). Att förstå deras fasta storlek, 0-baserad indexering, körningsgränser, fallgropan med `length`-fältet (kontra metod), och särskilt **när du använder en array kontra ArrayList** (fast/primitiv/snabb kontra dynamisk/praktisk) är väsentligt. Arrayer förekommer ständigt i algoritmer och prestandakritisk kod, medan kunskap om deras begränsningar (ingen förändring av storlek) förklarar varför dynamiska samlingar finns och vanligtvis föredras för allmän användning.