Java Arrays-Hilfsklasse

java.util.Arrays ist die Sammlung von Array-Hilfsmethoden der Standardbibliothek. Es handelt sich um eine final-Klasse mit ausschließlich static-Methoden — du instanziierst sie nie, sondern rufst ihre Methoden direkt auf: Arrays.sort(...), Arrays.toString(...) usw. Wenn du weißt, was sie enthält, wird dein Array-Code deutlich kürzer.

Dieses Kapitel ist eine geführte Tour. Sortieren und Kopieren haben eigene Kapitel; hier konzentrieren wir uns auf den Rest.

Importieren

import java.util.Arrays;

Fast jedes Beispiel unten setzt diesen Import voraus.

toString und deepToString

Wandelt ein Array in einen lesbaren String um. toString verarbeitet eindimensionale Arrays:

int[] data = {3, 1, 4};
String s = Arrays.toString(data);   // "[3, 1, 4]"

deepToString formatiert verschachtelte Arrays rekursiv:

int[][] grid = {{1, 2}, {3, 4}};
String s = Arrays.deepToString(grid);   // "[[1, 2], [3, 4]]"

Beide funktionieren für primitive und Objekt-Elementtypen.

equals und deepEquals

== vergleicht Array-Referenzen. Um Inhalte zu vergleichen:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
boolean same = Arrays.equals(a, b);   // true

Für verschachtelte Arrays verwendet man deepEquals:

int[][] g1 = {{1, 2}, {3, 4}};
int[][] g2 = {{1, 2}, {3, 4}};
boolean same = Arrays.deepEquals(g1, g2);   // true

Beide behandeln null == null als true.

hashCode und deepHashCode

Inhaltsbasierte Hashwerte, nützlich wenn eine Klasse ein Array kapselt und equals/hashCode benötigt:

int[] data = {1, 2, 3};
int h = Arrays.hashCode(data);

Wenn du equals so überschreibst, dass es Arrays.equals verwendet, musst du auch hashCode überschreiben und Arrays.hashCode nutzen, um den Vertrag einzuhalten.

fill

Setzt jedes Element auf einen Wert oder füllt einen Bereich:

int[] data = new int[5];
Arrays.fill(data, 7);              // {7, 7, 7, 7, 7}
Arrays.fill(data, 1, 4, 0);        // zero indexes 1..3

sort und parallelSort

In-Place-Sortierung, aufsteigend:

int[] data = {3, 1, 4, 1, 5};
Arrays.sort(data);                 // {1, 1, 3, 4, 5}

Bei sehr großen Arrays kann parallelSort verwendet werden, um die Arbeit auf mehrere Kerne zu verteilen. Die vollständige Sortiergeschichte — Primitive, Objekte, benutzerdefinierte Reihenfolgen — findest du im Kapitel Arrays sortieren.

binarySearch

Findet ein Element in einem sortierten Array in O(log n):

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 5);   // 2
int miss = Arrays.binarySearch(sorted, 6);  // negative — encodes insertion point

Wenn das Element fehlt, ist der Rückgabewert -(insertionPoint) - 1. miss == -4 bedeutet also, dass 6 an Index 3 gehören würde. Wenn die Eingabe nicht sortiert ist, ist das Ergebnis undefiniert — erst sortieren.

copyOf und copyOfRange

Gibt ein neues Array zurück und kopiert Werte aus einem bestehenden:

int[] data = {1, 2, 3, 4, 5};
int[] all   = Arrays.copyOf(data, data.length);    // exact copy
int[] grown = Arrays.copyOf(data, 8);              // padded with zeros
int[] slice = Arrays.copyOfRange(data, 1, 4);      // {2, 3, 4}

Diese werden ausführlich in Arrays kopieren behandelt.

asList

Verpackt ein Array von Referenzen als eine List fester Größe:

String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);

Die Liste ist an das Array gebunden — list.set(0, "z") ändert auch arr[0]. Die Größe ist fest, daher werfen add/remove eine Ausnahme. Bei primitiven Arrays verhält es sich nicht wie erwartet: Arrays.asList(new int[]{1, 2, 3}) erzeugt eine List<int[]> der Länge eins. Für Primitive zuerst mit Streams boxen.

stream

Gibt einen Stream aus einem numerischen oder Objekt-Array zurück:

int[] nums = {3, 1, 4, 1, 5};
int sum = Arrays.stream(nums).sum();
double avg = Arrays.stream(nums).average().orElse(0);

Für Objekt-Arrays gibt Arrays.stream(arr) einen Stream<T> zurück. Es gibt auch bereichsbegrenzte Formen — Arrays.stream(arr, from, to).

setAll und parallelSetAll

Füllt ein Array mithilfe einer Funktion des Index:

int[] squares = new int[6];
Arrays.setAll(squares, i -> i * i);
// {0, 1, 4, 9, 16, 25}

Verwende setAll, wenn du eine abgeleitete Sequenz möchtest und eine for-Schleife nur Rauschen wäre.

compare und mismatch (Java 9+)

Arrays.compare(a, b) gibt negativ, null oder positiv zurück — lexikografische Reihenfolge der Elemente:

int[] a = {1, 2, 3};
int[] b = {1, 2, 4};
int cmp = Arrays.compare(a, b);   // negative — a is smaller

Arrays.mismatch(a, b) gibt den Index des ersten abweichenden Elements zurück, oder -1 wenn sie gleich sind:

int diff = Arrays.mismatch(a, b);   // 2

Wenn ein Array ein echtes Präfix des anderen ist, wird das kürzere von compare als "kleiner" betrachtet, und mismatch gibt die Länge des kürzeren Arrays zurück:

int[] s = {1, 2};
int[] l = {1, 2, 3};
Arrays.compare(s, l);    // negative — s is a prefix, so it sorts first
Arrays.mismatch(s, l);   // 2 — they agree up to index 2, then s runs out

Diese sind nützlich, wenn du Reihenfolge oder "Wo haben sie sich unterschieden" benötigst, ohne die Schleife von Hand schreiben zu müssen.

Häufige Fallstricke

Einige Fehler passieren oft genug, um sie an einem Ort aufzulisten:

• == ist kein Inhaltsvergleich. a == b ist nur true, wenn beide Namen auf das gleiche Array-Objekt zeigen. Verwende Arrays.equals (oder Arrays.deepEquals für verschachtelte Arrays) zum Vergleich von Inhalten.
• toString ist flach. Arrays.toString(grid) auf einem int[][] gibt etwas wie [[I@1b6d3586, ...] aus — die inneren Arrays verwenden ihr Standard-Object.toString. Greife auf Arrays.deepToString zurück, wenn ein Array andere Arrays enthält.
• asList mit einem primitiven Array überrascht dich. Arrays.asList(new int[]{1, 2, 3}) ist eine List<int[]> mit einem Element, keine List<Integer> der Länge drei, weil int[] ein einzelnes Objekt ist. Verwende Arrays.stream(arr).boxed().toList() (Java 16+) um die gewünschte Liste zu erhalten.
• asList hat feste Größe. Es ist eine Sicht auf das ursprüngliche Array, daher funktioniert set, aber add und remove werfen UnsupportedOperationException. Verpacke es in new ArrayList<>(Arrays.asList(...)), wenn du es vergrößern möchtest.
• binarySearch benötigt ein sortiertes Array. Bei unsortierter Eingabe ist das Ergebnis undefiniert — es wird keine Ausnahme geworfen, sondern einfach ein falscher Index zurückgegeben. Erst sortieren.

Ein ausgearbeitetes Beispiel

Die Demo unten verbindet die meisten Methoden miteinander. Führe sie aus und vergleiche die Ausgabe mit den obigen Kommentaren — binarySearch gibt 5 für den Wert 5 zurück, ein negatives Ergebnis für ein fehlendes Element und die [red, green, blue]-Liste von asList:

Was kommt als Nächstes

Wir haben Arrays.sort nur kurz verwendet. Das nächste Kapitel, Arrays sortieren, befasst sich eingehend damit, wie die Sortierung für Primitive gegenüber Objekten, aufsteigend gegenüber absteigend und wie man nach eigenen Kriterien mit einem Comparator sortiert.

Übungen