it-swarm.com.de

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

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

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

Normalerweise möchten wir jedoch eher etwas 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]
1688
Alex Spurling

Seit Java 5 können Sie Arrays.toString(arr) oder Arrays.deepToString(arr) für Arrays innerhalb von Arrays verwenden. Beachten Sie, dass die Object[]-Version .toString() für jedes Objekt im Array aufruft. 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 ]
    
2246
Esko

Ü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));
330
Limbic System

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

- Da ich mich auf die Art von Myarray konzentrierte, um zu sehen, wie das geht. Ich wollte das Ding nicht durchlaufen: Ich wollte einen einfachen Aufruf, damit es ähnlich aussieht wie im Eclipse-Debugger und in myarray.toString ().

import Java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
96
Russ Bateman

In JDK1.8 können Sie Aggregatoperationen 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
*/
76
Eric Baker

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

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

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

40
Ross

Beginnend mit Java 8 könnte man auch die join()-Methode der String-Klasse nutzen, um Array-Elemente ohne Klammern auszudrucken und durch ein Trennzeichen der Wahl (das Leerzeichen für das gezeigte Beispiel) zu trennen unten):

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

Die Ausgabe wird "Hey there amigo!" Sein.

37
laylaylom

Arrays.toString

Als direkte Antwort ist die Lösung, die von mehreren, einschließlich @Esko , unter Verwendung der Arrays.toString und Arrays.deepToString - Methoden bereitgestellt wird, einfach die beste.

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

Nachfolgend versuche ich, einige der anderen vorgeschlagenen Methoden aufzulisten, wobei ich versuche, etwas zu verbessern. Der bemerkenswerteste Zusatz ist die Verwendung des Operators Stream.collect , wobei eine joiningCollector verwendet wird, um den String.join nachzuahmen tun.

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);
30
YoYo

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

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

Um tatsächlich eine Tabelle als zweidimensionale Tabelle drucken zu lassen, musste ich Folgendes tun: 

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

Es scheint, als sollte die Arrays.deepToString(arr)-Methode eine Trennzeichenfolge verwenden, leider nicht.

28
Rhyous

Vor Java 8

Wir hätten Arrays.toString(array) zum Drucken von eindimensionalen Arrays und Arrays.deepToString(array) für mehrdimensionale Arrays verwenden können. 

Java 8

Jetzt haben wir die Option Stream und lambda, um das Array zu drucken.

Drucken eines eindimensionalen Arrays:

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 Für den Fall, dass wir ein mehrdimensionales Array drucken wollen, können wir Arrays.deepToString(array) wie folgt verwenden:

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);
} 

Zu beachten ist nun, dass die Methode Arrays.stream(T[]), die im Fall von int[] uns Stream<int[]> zurückgibt, und dann die Methode flatMapToInt() jedes Element des Streams mit dem Inhalt eines zugeordneten Streams abbildet, 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

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

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. toString() verwenden

    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ünftes, sechstes], [siebtes, achtes]]

Ressource: Zugriff auf ein Array

16
Virtual

Die Verwendung von regular for loop ist meiner Meinung nach die einfachste Art, ein Array zu drucken ... Hier haben Sie einen Beispielcode, der auf Ihrem intArray basiert

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

Es gibt Ausgabe als Ihre 1, 2, 3, 4, 5

12
Andrew_Dublin

Ich bin vor kurzem auf diesen Beitrag in Vanilla #Java gestoßen. Es ist nicht sehr praktisch, Arrays.toString(arr); zu schreiben und dann die ganze Zeit Java.util.Arrays; Zu importieren.

Bitte beachten Sie, dass dies keinesfalls eine dauerhafte Lösung ist. Nur ein Hack, der das Debuggen vereinfachen kann.

Das direkte Drucken eines Arrays gibt die interne Darstellung und den Hashcode an. Jetzt haben alle Klassen Object als übergeordneten Typ. Also, warum nicht die Object.toString() hacken? Ohne Änderung sieht die Object-Klasse folgendermaßen aus:

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

Was passiert, wenn dies geändert wird 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 der Befehlszeile Folgendes hinzugefügt wird: -Xbootclasspath/p:target/classes.

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

Ich fand das ein recht nützlicher Hack und es wäre großartig, 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 etwas weitergeben wie ein System.out oder ein PrintWriter für solche Fälle.

8
Debosmit Ray

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

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

Es wird funktionieren, wenn Array Objekte enthält. Wenn Array primitive Typen enthält, können Sie Wrapper-Klassen verwenden, anstatt das Primitive direkt als .. zu speichern.

Beispiel: 

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

Ersetzen Sie es mit:

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

Update:

Ja ! Hierbei ist zu beachten, dass das Konvertieren eines Arrays in ein Objektarray OR zur Verwendung des Arrays des Objekts teuer ist und die Ausführung verlangsamen kann. Dies geschieht aufgrund der Art von Java, die als Autoboxing bezeichnet wird. 

Also nur zum Drucken, Es sollte nicht verwendet werden. Wir können eine Funktion erstellen, die ein Array als Parameter verwendet und das gewünschte Format als druckt

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

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

  1. stream: Arrays.stream(intArray).forEach
  2. methodenreferenz: ::println

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

Wenn Sie alle Elemente im Array in derselben Zeile drucken möchten, 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);

Ein anderer Weg ohne Methodenreferenz verwenden Sie einfach:

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

Um alle Antworten hinzuzufügen, ist das Drucken des Objekts als JSON-String ebenfalls eine Option.

Mit Jackson:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Verwendung von Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));
5
Jean Logeart

Es gibt eine weitere Möglichkeit, wenn Ihr Array vom Typ char [] ist:

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

druckt 

abc
5
Roam

Es gibt folgende Möglichkeit, ein Array zu drucken  

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }
4
Ravi Patel

Eine vereinfachte Abkürzung habe ich ausprobiert:

    int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

Es wird gedruckt

1
2
3

Bei diesem Ansatz sind keine Schleifen erforderlich. Dies ist am besten für kleine Arrays geeignet

4
Mohamed Idris

Sie können das Array durchlaufen und jedes Element ausdrucken, während Sie es durchlaufen. Zum Beispiel:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

Ausgabe:

item 1
item 2
item 3
4
Dylan Black
public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }
3
user3369011

Die Verwendung von Methoden org.Apache.commons.lang3.StringUtils.join (*) kann eine Option sein
Zum Beispiel:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

Ich habe die folgende Abhängigkeit verwendet 

<groupId>org.Apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
3
Haim Raman

For-Each-Schleife kann auch zum Drucken von Array-Elementen verwendet werden:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);
3
hasham.98

Dies wird als Duplikat für Drucken eines Bytes [] markiert. Hinweis: Für ein Bytearray gibt es zusätzliche Methoden, die geeignet sein können.

Sie können es als Zeichenfolge drucken, wenn es ISO-8859-1-Zeichen enthält.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

oder wenn es eine UTF-8-Zeichenfolge enthält

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

oder wenn Sie es als Hexadezimalwert drucken möchten.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

oder wenn Sie es als base64 drucken möchten.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

oder wenn Sie ein Array mit signierten Bytewerten drucken möchten

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

oder wenn Sie ein Array von vorzeichenlosen Byte-Werten drucken möchten

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.
2
Peter Lawrey
// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

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

output: [1, 2, 3, 4, 5]

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

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

output: [John, Mary, Bob]
1
fjnk

Es gibt verschiedene Möglichkeiten, ein Array-Element zu drucken. Zunächst einmal werde ich erklären, was ein Array ist. .. Array ist eine einfache Datenstruktur zum Speichern von Daten. Wenn Sie ein Array definieren, weisen Sie einen Satz zusätzlicher Speicherblöcke zu im RAM.Diese Speicherblöcke werden einer Einheit entnommen.

Ok, ich werde so ein Array erstellen,

class demo{
      public static void main(String a[]){

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

           System.out.print(number);
      }
}

Nun schau dir die Ausgabe an,

 enter image description here

Sie können einen unbekannten String in gedruckter Form sehen. Wie bereits erwähnt, wird die Speicheradresse, deren Array (Number Array) deklariert ist, gedruckt. Wenn Sie Elemente im Array anzeigen möchten, können Sie "for loop" wie folgt verwenden.

class demo{
      public static void main(String a[]){

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

           int i;

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

Nun schau dir die Ausgabe an,

 enter image description here

Ok, Erfolgreich gedruckte Elemente eines Array mit einer Dimension ... Nun werde ich ein Array mit zwei Dimensionen betrachten. Ich werde ein Array mit zwei Dimensionen als "number2" deklarieren und die Elemente mit dem Schlüsselwort "Arrays.deepToString ()" drucken Sie müssen die Bibliothek "Java.util.Arrays" importieren.

 import Java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};`

           System.out.print(Arrays.deepToString(number2));
      }
}

betrachten die Ausgabe,

 enter image description here

Zur gleichen Zeit können 2D-Elemente mit zwei for-Schleifen gedruckt werden. Vielen Dank!

0
GT_hash

In Java 8:

Arrays.stream(myArray).forEach(System.out::println);
0
Mehdi

Wenn Sie Commons.Lang library verwenden, können Sie Folgendes tun:

ArrayUtils.toString(array)

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

Ausgabe:

{1,2,3,4,5}
{John,Mary,Bob}
0
Pradip Karki

wenn Sie jdk 8 ausführen. 

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}


int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

ausgabe:

[7,3,5,1,3]
0
shellhub