Wie man ein Array in Java ausgibt

Ein Array direkt an System.out.println zu übergeben gibt fast nie das gewünschte Ergebnis — statt der Elemente erscheint etwas wie [I@1b6d3586. Arrays überschreiben toString() nicht, daher gibt die Standard-Object-Version den Typ und einen Identitäts-Hash aus. Dieses Kapitel zeigt die idiomatischen Lösungen: Arrays.toString für eindimensionale Arrays, Arrays.deepToString für verschachtelte, String.join für benutzerdefinierte Trennzeichen und eine manuelle Schleife, wenn vollständige Kontrolle benötigt wird.

Warum ein einfaches Ausgeben fehlschlägt

Das Standard-toString(), das ein Array von Object erbt, gibt eine Klassenbezeichnung plus einen Hash-Code zurück — nicht den Inhalt:

int[] numbers = {3, 1, 4};
System.out.println(numbers);       // [I@1b6d3586
System.out.println("" + numbers);  // same reference string

Das [I bedeutet "Array von int"; das Hex nach @ ist der Identitäts-Hash, der sich zwischen Läufen ändert. Die Verkettung des Arrays in einen String hilft nicht, da die Verkettung ebenfalls toString() aufruft. Die Lösung besteht darin, einen Hilfsaufruf zur Formatierung der Elemente zu verwenden.

Arrays.toString für eine Dimension

java.util.Arrays.toString durchläuft ein eindimensionales Array und gibt einen lesbaren, durch Komma getrennten String in eckigen Klammern zurück:

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

String[] words = {"alpha", "beta"};
System.out.println(Arrays.toString(words));   // [alpha, beta]

Die Methode ist für jeden primitiven Array-Typ (int[], double[], boolean[], …) und für Object[] überladen, funktioniert also mit jedem flachen Array. Bei Objekt-Arrays ruft sie das eigene toString() jedes Elements auf.

Arrays.deepToString für verschachtelte Arrays

Arrays.toString geht nur eine Ebene tief. Bei einem 2D-Array formatiert es das äußere Array, gibt aber jedes innere Array als Referenz aus. Verwende Arrays.deepToString, um rekursiv durch jede Ebene zu gehen:

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

Greife auf deepToString zurück, wenn das Array andere Arrays enthält — Matrizen, unregelmäßige Arrays, Arrays von Arrays von Objekten.

Ansatz	Am besten für	Ausgabestil
`Arrays.toString`	1D primitive oder Objekt-Arrays	`[a, b, c]`
`Arrays.deepToString`	verschachtelte / mehrdimensionale Arrays	`[[a, b], [c, d]]`
`String.join`	`String[]` mit benutzerdefiniertem Trennzeichen	`a, b, c` (ohne Klammern)
manuelle Schleife / `StringBuilder`	vollständige Kontrolle über das Format	alles, was du aufbaust

Benutzerdefinierte Formatierung

Wenn das Format mit eckigen Klammern nicht das gewünschte ist, verbindet String.join ein String[] (oder jedes CharSequence-Iterable) mit einem Trennzeichen deiner Wahl und ohne umgebende Klammern:

String[] words = {"alpha", "beta", "gamma"};
System.out.println(String.join(" | ", words)); // alpha | beta | gamma

Für Nicht-String-Arrays oder vollständig benutzerdefinierte Ausgaben gibt eine Schleife mit einem StringBuilder vollständige Kontrolle über Trennzeichen, Präfixe und die Formatierung einzelner Elemente. Streams sind eine weitere Option: Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(", ")).

Ein ausführbares Beispiel

Das folgende Programm stellt die Ansätze gegenüber: Arrays.toString auf flachem int[] und String[], den Unterschied zwischen flach und tief bei einem 2D-Array, String.join für ein benutzerdefiniertes Trennzeichen und einen manuell aufgebauten StringBuilder. Die shallow-Zeile prüft, ob das flache toString des 2D-Arrays noch innere Referenzen enthält, und gibt daher ein stabiles true statt eines laufvariablen Hashs aus.

java— editable, runs on the server

import java.util.Arrays;

public class ArrayPrinter {
    public static void main(String[] args) {
        int[] numbers = {3, 1, 4, 1, 5};

// Arrays.toString is the standard way for a one-dimensional array.
        System.out.println("toString: " + Arrays.toString(numbers));

String[] words = {"alpha", "beta", "gamma"};
        System.out.println("words: " + Arrays.toString(words));

// For a nested array, toString prints inner references; deepToString recurses.
        int[][] grid = {{1, 2}, {3, 4}};
        System.out.println("shallow: " + Arrays.toString(grid).startsWith("[[I@"));
        System.out.println("deep: " + Arrays.deepToString(grid));

// String.join builds a custom-delimited line from a String array.
        System.out.println("joined: " + String.join(" | ", words));

// A manual loop gives full control over the format.
        StringBuilder sb = new StringBuilder("{");
        for (int i = 0; i < numbers.length; i++) {
            sb.append(numbers[i]);
            if (i < numbers.length - 1) {
                sb.append("; ");
            }
        }
        sb.append("}");
        System.out.println("manual: " + sb);
    }
}

Was man aus der Ausführung mitnehmen kann:

toString: [3, 1, 4, 1, 5] zeigt, wie Arrays.toString ein flaches int[] in lesbaren, eingeklammerten Text umwandelt.
words: [alpha, beta, gamma] bestätigt, dass dieselbe Methode bei Objekt-Arrays funktioniert, indem sie das toString() jedes Elements aufruft.
shallow: true beweist, dass Arrays.toString bei einem 2D-Array die inneren Arrays als [[I@...-Referenzen belässt, weshalb das Ergebnis mit [[I@ beginnt.
deep: [[1, 2], [3, 4]] zeigt, wie Arrays.deepToString rekursiv in die verschachtelten Arrays eindringt, um jedes Element auszugeben.
joined: alpha | beta | gamma und manual: {3; 1; 4; 1; 5} zeigen, wie String.join und eine StringBuilder-Schleife klammernfreie, benutzerdefiniert getrennte Ausgaben erzeugen.

Übungen

Übung

Was gibt Arrays.toString(grid) aus, wenn grid ein zweidimensionales int-Array wie {{1, 2}, {3, 4}} ist?

Es gibt das äußere Array aus, zeigt aber jedes innere Array als Referenz wie [I@..., weshalb du für den vollständigen Inhalt Arrays.deepToString benötigst.Es gibt den vollständig verschachtelten Inhalt [[1, 2], [3, 4]] genau wie deepToString aus.Es wirft eine Ausnahme, weil toString nur eindimensionale Arrays akzeptiert.Es gibt eine einzelne, flach gedruckte Liste [1, 2, 3, 4] ohne Verschachtelung aus.