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

In Java werden Arrays nicht überschrieben toString(). Wenn Sie also versuchen, eines direkt zu drucken, erhalten Sie das className+ '@' + das Hex des hashCodeArrays, 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 möchten wir eigentlich etwas Ähnliches [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]

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()jedes Objekt im Array aufruft . Die Ausgabe ist sogar genau so dekoriert, 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 ]

Überprüfen Sie immer zuerst die Standardbibliotheken.

import java.util.Arrays;

Dann versuche es:

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

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

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

Dies ist jedoch gut zu wissen, da ich bei "Überprüfen Sie immer zuerst die Standardbibliotheken zuerst" nie auf den Trick von gestoßen wäre Arrays.toString( myarray )

- seit ich mich auf die Art von Myarray konzentriert habe, um zu sehen, wie das geht. Ich wollte das Ding nicht durchlaufen müssen: Ich wollte einen einfachen Aufruf, damit es ähnlich wie im Eclipse-Debugger und myarray herauskommt. ToString () tat es einfach nicht.

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

Ab Java 8 kann man auch die join()von der String-Klasse bereitgestellte Methode nutzen , um Array-Elemente ohne Klammern auszudrucken und durch ein Trennzeichen der Wahl zu trennen (dies ist das Leerzeichen für das unten gezeigte Beispiel):

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

Die Ausgabe wird "Hey there amigo!" Sein.

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

Arrays.toString

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

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

Im Folgenden versuche ich, einige der anderen vorgeschlagenen Methoden aufzulisten, um sie ein wenig zu verbessern. Die bemerkenswerteste Ergänzung ist die Verwendung des Stream.collectOperators mit a , um nachzuahmen, was der Operator tut.joining CollectorString.join

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

Vor Java 8

Wir hätten Arrays.toString(array)eindimensionale Arrays und Arrays.deepToString(array)mehrdimensionale Arrays drucken können .

Java 8

Jetzt haben wir die Möglichkeit , Streamund lambdadas 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
Mary
Bob

Drucken eines mehrdimensionalen Arrays Nur für den Fall, dass wir ein mehrdimensionales Array drucken möchten, können wir Folgendes verwenden Arrays.deepToString(array):

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

Nun ist zu beachten, dass die Methode Arrays.stream(T[]), die int[]uns zurückgibt Stream<int[]>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
Mary
Lee
Bob
Johnson

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

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

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

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

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

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

Ressource: Zugriff auf ein Array

Die Verwendung der regulären for- Schleife 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 kürzlich auf diesen Beitrag in Vanilla #Java gestoßen . Es ist nicht sehr bequem zu schreiben Arrays.toString(arr);und dann die java.util.Arrays;ganze Zeit zu importieren .

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

Wenn Sie ein Array direkt drucken, erhalten Sie die interne Darstellung und den Hashcode. Jetzt haben alle Klassen Objectden übergeordneten Typ. Also, warum nicht die hacken Object.toString()? Ohne Änderung sieht die Object-Klasse folgendermaßen aus:

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

Was ist, 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 toString(..)kann das nun leicht geändert werden deepToString(..), um Unterstützung für Arrays hinzuzufügen, die andere Arrays enthalten.

Ich fand das ein ziemlich 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 Zeichenfolgendarstellungen problematisch sein können. Vielleicht geben Sie so etwas wie ein System.outoder ein PrintWriterfür solche Eventualitäten.

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

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

Es wird funktionieren, wenn das ArrayObjekte enthält. Wenn das Arrayprimitive Typen enthält, können Sie Wrapper-Klassen verwenden, anstatt das Grundelement direkt als .. zu speichern.

Beispiel:

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

Ersetzen Sie es durch:

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

Update:

Ja ! Dies ist zu erwähnen, dass das Konvertieren eines Arrays in ein Objektarray ODER die Verwendung des Objektarrays kostspielig ist und die Ausführung verlangsamen kann. Es geschieht durch die Natur von Java, die Autoboxing genannt wird.

Es sollte also nur zum Drucken 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 es einfach. Es gibt zwei Schlüsselwörter

1. Strom: 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 printanstelle von printlnie

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

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

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

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

druckt

abc

Um alle Antworten zu ergänzen, können Sie das Objekt auch als JSON-Zeichenfolge drucken.

Verwenden von Jackson:

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

Verwenden von Gson:

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

Sie können das Array durchlaufen und jedes Element während der Schleife ausdrucken. 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

Es gibt folgende Möglichkeiten, 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 Verknüpfung, die ich ausprobiert habe, ist folgende:

    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, und dies ist am besten nur für kleine Arrays geeignet

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

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 org.apache.commons.lang3.StringUtils.join (*) -Methoden kann eine Option sein
. 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>

Dies ist als Duplikat zum Drucken eines Bytes [] markiert . Hinweis: Für ein Byte-Array gibt es möglicherweise zusätzliche Methoden.

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 hexadezimal 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 von vorzeichenbehafteten 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 Bytewerten 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]

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]

In Java 8:

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

Bei Verwendung der Commons.Lang-Bibliothek , können wir 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 die Adresse des Array-Elements auf der Konsole in Java drucken.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

Es gibt verschiedene Möglichkeiten, Array-Elemente zu drucken. Zunächst erkläre ich, 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 in RAM.Diese Speicherblöcke werden eine Einheit genommen ..

Ok, ich werde ein Array wie dieses erstellen,

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

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

           System.out.print(number);
      }
}

Schauen Sie sich nun die Ausgabe an,

Sie können sehen, dass eine unbekannte Zeichenfolge gedruckt wird. Wie bereits erwähnt, wird die Speicheradresse gedruckt, deren Array (Zahlenarray) deklariert ist. 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]+"  ");
           }
      }
}

Schauen Sie sich nun die Ausgabe an,

Ok, Elemente eines eindimensionalen Arrays erfolgreich gedruckt. Jetzt werde ich ein zweidimensionales Array betrachten. Ich werde ein zweidimensionales Array 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 Sie die Ausgabe,

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