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

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

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

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

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+.)

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.

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

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.

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

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

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]

2. toString() verwenden

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

Ressource: Zugriff auf ein Array

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

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.

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
} 

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

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

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

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

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

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

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

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>

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

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.

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

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,

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,

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,

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

In Java 8:

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

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}

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]