Frage Was ist der einfachste Weg, um ein Java-Array zu drucken?


In Java werden Arrays nicht überschrieben toString()Wenn Sie also versuchen, einen direkt zu drucken, erhalten Sie den Klassennamen + @ + das Hex des hashCode des Arrays, wie durch definiert Object.toString():

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

Aber normalerweise möchten wir etwas mehr wie [1, 2, 3, 4, 5]. Was ist der einfachste Weg, das zu tun? Hier einige Beispiele für Ein- und Ausgänge:

// 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]

1526
2018-01-03 20:39


Ursprung


Antworten:


Seit Java 5 können Sie verwenden Arrays.toString(arr) oder Arrays.deepToString(arr) für Arrays innerhalb von Arrays. Notiere dass der Object[] Version Anrufe .toString() auf jedes Objekt im Array. Die Ausgabe ist sogar genau so gestaltet, wie Sie es wünschen.

Beispiele:

Einfaches Array:

String[] array = new String[] {"John", "Mary", "Bob"};
System.out.println(Arrays.toString(array));

Ausgabe:

[John, Mary, Bob]

Verschachteltes Array:

String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
System.out.println(Arrays.toString(deepArray));
//output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
System.out.println(Arrays.deepToString(deepArray));

Ausgabe:

[[John, Mary], [Alice, Bob]]

double Array:

double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
System.out.println(Arrays.toString(doubleArray));

Ausgabe:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

int Array:

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

Ausgabe:

[7, 9, 5, 1, 3 ]

2035
2018-01-03 20:48



Überprüfen Sie immer zuerst die Standardbibliotheken. Versuchen:

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

oder wenn Ihr Array andere Arrays als Elemente enthält:

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

304
2018-05-12 21:01



Das ist aber schön zu wissen, denn "immer zuerst die Standardbibliotheken prüfen" wäre ich nie auf den Trick gestoßen Arrays.toString( myarray )

- Seitdem ich mich auf die Art von Myarray konzentriert habe, um zu sehen, wie das geht. Ich wollte nicht durch das Ding iterieren: Ich wollte einen einfachen Aufruf, damit es ähnlich wie im Eclipse-Debugger ausgegeben wird, und myarray.toString () hat es gerade nicht gemacht.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

85
2018-02-06 23:35



In JDK1.8 können Sie aggregierte Operationen und einen Lambda-Ausdruck verwenden:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

70
2018-01-03 21:44



Wenn Sie Java 1.4 verwenden, können Sie stattdessen Folgendes tun:

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

(Dies funktioniert natürlich auch in 1.5+.)


37
2017-12-23 18:51



Ab Java 8 könnte man auch die Vorteile von join() Methode, die von der String-Klasse um Array-Elemente ohne die Klammern auszudrucken und durch ein Trennzeichen der Wahl getrennt zu sein (welches das Leerzeichen für das unten gezeigte Beispiel ist):

String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting) 

Die Ausgabe wird "Hey da Amigo!" Sein.


35
2017-10-05 19:13



Arrays.deepToString(arr) druckt nur auf einer Zeile.

int[][] table = new int[2][2];

Um tatsächlich einen Tisch als zweidimensionalen Tisch zu drucken, musste ich Folgendes tun:

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

Es scheint wie die Arrays.deepToString(arr) Methode sollte eine Trennzeichenfolge nehmen, aber leider nicht.


27
2018-03-11 05:36



Arrays.toString

Als direkte Antwort die Lösung von mehreren, einschließlich @Esko, Verwendung der Arrays.toString und Arrays.deepToString Methoden, ist einfach das Beste.

Java 8 - Stream.collect (joining ()), Stream.forEach

Im Folgenden versuche ich, einige der anderen vorgeschlagenen Methoden aufzulisten, versuche, ein wenig zu verbessern, mit der bemerkenswertesten Ergänzung ist die Verwendung der Stream.collect Betreiber, mit a joining  Collector, um nachzuahmen, was String.join macht.

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

26
2018-06-19 06:10



Vor Java 8 hätten wir gebraucht Arrays.toString(array) eindimensionales Array zu drucken und Arrays.deepToString(array) für mehrdimensionale Arrays. Wir haben die Option von Stream und lambda in Java 8, das auch für das Drucken des Arrays verwendet werden kann.

Eindimensionales Array drucken:

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

Die Ausgabe ist:

[1, 2, 3, 4, 5]
  [John, Mary, Bob]
  1
  2
  3
  4
  5
  John
  Maria
  Bob

Mehrdimensionales Array drucken Nur für den Fall, dass wir mehrdimensionale Arrays drucken möchten, können wir sie verwenden Arrays.deepToString(array) wie:

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

Jetzt ist der Punkt zu beobachten, dass die Methode Arrays.stream(T[]), die im Falle von int[] gibt uns zurück Stream<int[]> und dann Methode flatMapToInt() bildet jedes Element des Datenstroms mit dem Inhalt eines zugeordneten Datenstroms ab, der durch Anwenden der bereitgestellten Zuordnungsfunktion auf jedes Element erzeugt wird.

Die Ausgabe ist:

[11, 12], [21, 22], [31, 32, 33]]
  [John, Bravo], [Mary, Lee], [Bob, Johnson]]
  11
  12
  21
  22
  31
  32
  33
  John
  Bravo
  Maria
  Lee
  Bob
  Johnson


23
2018-01-24 04:25



for(int n: someArray) {
    System.out.println(n+" ");
}

17
2017-08-07 14:05



Verschiedene Möglichkeiten zum Drucken von Arrays in Java:

  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]

  1. Verwenden toString()

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

Ausgabe: [Eins, Zwei, Drei, Vier]

  1. 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ünfter, Sechster], [Siebter, Achter]]

Ressource: Zugriff auf ein Array


17
2017-12-27 23:31