Hvordan fungerer arrays i Java?

Question

Accepted Answer

Et **array** er en fast størrelse, ordnet samling af elementer af **samme type**, gemt fortløbende i hukommelsen. Arrays er fundamentale, men deres faste størrelse betyder, at du ofte foretrækker `ArrayList` til dynamiske samlinger. ## Deklarering og oprettelse af arrays ```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!) ``` Arrays har en **fast størrelse** sat ved oprettelse — du kan ikke udvide eller formindske dem. Elementer får standardværdier, der er passende for typen (`0`, `0.0`, `false`, `null`). ## En almindelig fælde: length er et felt ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Array `length` er et felt; String `length()` og samlings `size()` er metoder — et hyppigt forvirrings punkt. ## Grænsekontrol ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` Java kaster en undtagelse for adgang uden for grænserne (i modsætning til C, som har udefineret adfærd) — mere sikkert, men du skal forblive inden for `0` til `length-1`. ## Iteration ```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; } ``` ## Multidimensionelle arrays ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Arrays versus ArrayList — hvornår bruger man hvad ```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); ``` Brug et almindeligt array til fast størrelse, ydelses følsomhed eller primitive data; brug `ArrayList` når størrelsen ændres eller du har brug for praktiske operationer. ## Hvorfor det betyder noget Arrays er en grundlæggende datastruktur i Java — hurtig, hukommelseseffektiv, fortløbende lagring brugt direkte og som grundlag for mange samlinger (ArrayList omslutter et array). Ad at forstå deres faste karakteristika, 0-baseret indeksering, køretidsgrænsekontrol, `length` feltet (versus metode) fælden, og især **hvornår man bruger et array versus ArrayList** (fast/primitiv/hurtig versus dynamisk/praktisk) er afgørende. Arrays vises konstant i algoritmer og ydelses kritisk kode, mens forståelse af deres begrænsninger (ingen ændring af størrelse) forklarer hvorfor dynamiske samlinger eksisterer og normalt foretrækkes til generel brug.