Hvordan fungerer arrays i Java?

Question

IT Interview Practice · 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.

Deklarering og oprettelse af arrays

En almindelig fælde: length er et felt

Grænsekontrol

Iteration

Multidimensionelle arrays

Arrays versus ArrayList — hvornår bruger man hvad

Hvorfor det betyder noget

Relaterede spørgsmål