Häufige Java-Array-Operationen

Arrays selbst haben nicht viele Methoden. Das Array-Objekt stellt ein Feld (length) und eine Methode (clone()) bereit. Alles andere — Ausgaben, Füllen, Suchen, Vergleichen — befindet sich in der Hilfsklasse java.util.Arrays, die wir im nächsten Kapitel ausführlich behandeln. Dieses Kapitel ist eine Übersicht der alltäglichen Operationen: was sie tun und welchen Aufruf man verwenden sollte.

Diese Seite behandelt das Lesen der Größe, Ausgabe, Füllen, Vergleichen, Suchen, Kopieren und Umwandeln eines Arrays in eine List. Für jede Aufgabe gibt es in der Regel einen idiomatischen Aufruf — das Ziel ist, den richtigen zu erkennen.

Länge

int[] data = {3, 1, 4, 1, 5, 9, 2, 6};
System.out.println(data.length);   // 8

Feld, keine Methode — keine Klammern. length ist nach der Erstellung des Arrays unveränderlich. Um ein Array zu „vergrößern", wird ein neues angelegt und kopiert (siehe Kopieren weiter unten). Beachte: length ist ein Feld bei Arrays, während String und Kollektionen wie List stattdessen eine Methode length() bzw. size() verwenden — eine häufige Fehlerquelle.

Ein Array ausgeben

System.out.println(arr) gibt etwas wie [I@1540e19d aus — Klassenname und Hash. Das ist fast nie das Gewünschte. Verwende Arrays.toString:

import java.util.Arrays;

int[] data = {3, 1, 4, 1, 5};
System.out.println(Arrays.toString(data));   // [3, 1, 4, 1, 5]

Für 2D-Arrays verwende Arrays.deepToString:

int[][] grid = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(grid));   // [[1, 2], [3, 4]]

Füllen

Um jeden Slot auf denselben Wert zu setzen:

int[] zeros = new int[5];
Arrays.fill(zeros, 7);              // {7, 7, 7, 7, 7}

Eine Bereichsform füllt nur [fromIndex, toIndex):

int[] data = new int[10];
Arrays.fill(data, 3, 7, 1);         // ones in positions 3, 4, 5, 6

Gleichheit

== vergleicht bei Arrays Referenzen, nicht Inhalte. Für elementweise Gleichheit verwende Arrays.equals:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b);                    // false (different objects)
System.out.println(Arrays.equals(a, b));       // true

Für verschachtelte Arrays verwende Arrays.deepEquals. Hinsichtlich null-sicherer Semantik betrachten beide Hilfsmethoden null == null als true.

Suchen

Ein linearer Scan mit einer klassischen Schleife ist für kleine Arrays oder unbekannte Reihenfolge ausreichend:

int[] data = {7, 3, 9, 1, 5};
int target = 9;
int found = -1;
for (int i = 0; i < data.length; i++) {
  if (data[i] == target) { found = i; break; }
}

Für ein sortiertes Array ist Arrays.binarySearch O(log n):

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 7);   // 3

Wenn der Wert nicht vorhanden ist, gibt binarySearch eine negative Zahl zurück, die kodiert, wo er eingefügt werden würde: -(insertionPoint) - 1. Ein Rückgabewert von -8 bedeutet also „nicht gefunden, gehört an Index 7." Um daraus den Einfügepunkt zu berechnen: int insert = -(result) - 1;.

Kopieren

Um ein neues Array mit demselben Inhalt zu erhalten:

int[] data = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(data, data.length);

Um beim Kopieren die Größe zu ändern — mit Standardwerten auffüllen, wenn länger, oder abschneiden, wenn kürzer:

int[] longer  = Arrays.copyOf(data, 8);    // {1, 2, 3, 4, 5, 0, 0, 0}
int[] shorter = Arrays.copyOf(data, 3);    // {1, 2, 3}

Um einen Ausschnitt zu kopieren:

int[] middle = Arrays.copyOfRange(data, 1, 4);   // {2, 3, 4}

from ist inklusive, to ist exklusive — die übliche halboffene Java-Konvention.

Die einzige Kopiermethode, die am Array selbst liegt, ist clone():

int[] data = {1, 2, 3};
int[] dup  = data.clone();          // {1, 2, 3}, a separate array

clone() erstellt eine flache Kopie: Bei einem Array von Objekten (oder einem 2D-Array, das ein Array von Arrays ist) werden die inneren Referenzen geteilt, nicht dupliziert. Mehr zum Thema Kopieren — einschließlich System.arraycopy und tiefen Kopien — findet sich im dedizierten Kapitel Arrays kopieren.

Umwandlung in eine List

Arrays.asList(...) umhüllt ein Array (von Referenzen) als List fester Größe:

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

Die Größe ist unveränderlich: add/remove werfen UnsupportedOperationException, aber list.set(...) ist möglich. Beachte: asList funktioniert bei primitiven Arrays nicht wie erwartet — Arrays.asList(new int[]{1, 2, 3}) erzeugt eine List<int[]> der Länge 1, keine List<Integer>. Für primitive Typen verwendet man Streams:

import java.util.stream.IntStream;

int[] nums = {1, 2, 3};
List<Integer> boxed = IntStream.of(nums).boxed().toList();

Hashing

Arrays.hashCode(arr) erzeugt einen inhaltsbasierten Hash, den man in equals/hashCode-Implementierungen einer enthaltenden Klasse verwenden kann:

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

Für verschachtelte Arrays verwendet man Arrays.deepHashCode.

Ein durchgearbeitetes Beispiel

Was kommt als Nächstes

Die soeben verwendeten Hilfsmethoden — toString, fill, equals, copyOf, binarySearch, sort — befinden sich alle in derselben Klasse: java.util.Arrays. Das nächste Kapitel behandelt die Arrays-Hilfsklasse systematisch, einschließlich der Aspekte, die hier nur kurz angesprochen wurden.

Übungen