Wie kann man ein Java-Array am einfachsten ausdrucken?

Question

In Java überschreiben Arrays nicht die toString() Wenn Sie also versuchen, einen direkt zu drucken, erhalten Sie die Meldung className + '@' + das Hexadezimalzeichen der [hashCode](https://en.wikipedia.org/wiki/Java_hashCode()) des Arrays, wie definiert durch Object.toString() :

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

Aber normalerweise wollen wir eher etwas wie [1, 2, 3, 4, 5] . Wie lässt sich das am einfachsten bewerkstelligen? Hier sind einige Beispiele für Eingaben und Ausgaben:

// Array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};
//output: [1, 2, 3, 4, 5]

// Array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};
//output: [John, Mary, Bob]

Answer 1

Verschiedene Arten, Arrays in Java zu drucken:

1. Einfacher Weg

   List<String> list = new ArrayList<String>();
   list.add("One");
   list.add("Two");
   list.add("Three");
   list.add("Four");
   // Print the list in console
   System.out.println(list);

Ausgabe: [Eins, Zwei, Drei, Vier]

2. Verwendung von toString()

   String[] array = new String[] { "One", "Two", "Three", "Four" };
   System.out.println(Arrays.toString(array));

Ausgabe: [Eins, Zwei, Drei, Vier]

3. Array von Arrays drucken

   String[] arr1 = new String[] { "Fifth", "Sixth" };
   String[] arr2 = new String[] { "Seventh", "Eight" };
   String[][] arrayOfArray = new String[][] { arr1, arr2 };
   System.out.println(arrayOfArray);
   System.out.println(Arrays.toString(arrayOfArray));
   System.out.println(Arrays.deepToString(arrayOfArray));

Ausgabe: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[Fünfte, Sechste], [Siebte, Achte]]

Ressource: Zugriff auf ein Array

Answer 2

Mit regelmäßigen para Schleife ist meiner Meinung nach der einfachste Weg, ein Array zu drucken. Hier haben Sie einen Beispielcode basierend auf Ihrem intArray

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

Die Ausgabe ist wie Ihre 1, 2, 3, 4, 5

Answer 3

Es sollte immer funktionieren, egal welche JDK-Version Sie verwenden:

System.out.println(Arrays.asList(array));

Es funktioniert, wenn die Array enthält Objekte. Wenn die Array primitive Typen enthält, können Sie Wrapper-Klassen verwenden, anstatt die primitiven Typen direkt als zu speichern.

Beispiel:

int[] a = new int[]{1,2,3,4,5};

Ersetzen Sie ihn durch:

Integer[] a = new Integer[]{1,2,3,4,5};

Update :

Ja! Dies ist zu erwähnen, dass die Umwandlung eines Arrays in ein Objekt-Array oder die Verwendung des Objekt-Arrays kostspielig ist und die Ausführung verlangsamen kann.

Wir können eine Funktion erstellen, die ein Array als Parameter nimmt und das gewünschte Format wie folgt ausgibt

public void printArray(int [] a){
        //write printing code
}

Answer 4

Ich bin auf diesen Beitrag in Vanille #Java vor kurzem. Es ist nicht sehr bequem, zu schreiben Arrays.toString(arr); und dann importieren java.util.Arrays; Die ganze Zeit über.

Bitte beachten Sie, dass dies keineswegs eine dauerhafte Lösung ist. Nur ein Hack, der die Fehlersuche vereinfachen kann.

Das direkte Drucken eines Arrays ergibt die interne Darstellung und den HashCode. Jetzt haben alle Klassen Object als übergeordneten Typ. Warum also nicht die Object.toString() ? Ohne Änderung sieht die Klasse Object wie folgt aus:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Was wäre, wenn dies geändert würde in:

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Diese modifizierte Klasse kann einfach zum Klassenpfad hinzugefügt werden, indem man folgendes in die Befehlszeile einträgt: -Xbootclasspath/p:target/classes .

Jetzt, mit der Verfügbarkeit von deepToString(..) seit Java 5 ist die toString(..) kann leicht geändert werden in deepToString(..) um Unterstützung für Arrays hinzuzufügen, die andere Arrays enthalten.

Ich fand dies einen sehr nützlichen Hack und es wäre toll, wenn Java dies einfach hinzufügen könnte. Ich verstehe mögliche Probleme mit sehr großen Arrays, da die String-Darstellungen problematisch sein könnten. Vielleicht sollte man etwas wie eine System.out oder eine PrintWriter für solche Eventualitäten.

Answer 5

In Java 8 ist es einfach. Es gibt zwei Schlüsselwörter

1. Strom: Arrays.stream(intArray).forEach

2. Referenzmethode: ::println

   int[] intArray = new int[] {1, 2, 3, 4, 5};
   Arrays.stream(intArray).forEach(System.out::println);

Wenn Sie alle Elemente des Arrays in der gleichen Zeile ausgeben wollen, verwenden Sie einfach print anstelle von println d.h.

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

Eine andere Möglichkeit ohne Methodenbezug einfach verwenden:

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