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

Question

In Java-Arrays nicht überschreiben toString(), also, wenn Sie versuchen, eine direkt zu drucken, können Sie den Klassenname erhalten + @ + die 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 '[I@3343c8b3'

Aber in der Regel würden wir tatsächlich etwas mehr wie [1, 2, 3, 4, 5] wollen. Was ist der einfachste Weg, dies zu tun? Hier sind einige Beispiele 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]

Answer 1

Da Java 5 Sie verwenden können, Arrays.toString(arr) oder Arrays.deepToString(arr) für Arrays innerhalb Arrays. Beachten Sie, dass die Object[] Version .toString() für jedes Objekt im Array aufruft. Der Ausgang wird auch in der genauen Art und Weise dekoriert Sie fragt.

Beispiele:

• Einfache Array:

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

  Ausgabe:

  [John, Mary, Bob]
  

• Verschachtelte 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 ]
  

Answer 2

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

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

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

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

Answer 3

Das ist schön zu wissen, aber, wie für „immer die Standardbibliotheken überprüfen Sie zuerst“ Ich würde nie auf den Trick von Arrays.toString( myarray ) gestolpert

- da ich von der Art der myarray wurde konzentriert, um zu sehen, wie dies zu tun. Ich wollte nicht haben, durch die Sache zu durchlaufen. Ich einen einfachen Anruf wollte es ähnlich kommen zu machen, was ich in den Eclipse-Debugger und myarray.toString sehen () einfach nicht tat es

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

Answer 4

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

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

Answer 5

Wenn Sie mit Java 1.4, können Sie stattdessen tun:

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

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

Answer 6

Beginnend mit Java 8 könnte man auch die Vorteile der join() Methode nimmt die String-Klasse Arrayelemente auszudrucken, ohne die Klammern und durch ein Trennzeichen der Wahl getrennt (das das Leerzeichen ist für das gezeigte Beispiel unten):

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

Der Ausgang wird "Hey amigo!".

Answer 7

Arrays.toString

Als direkte Antwort, die Lösung durch mehr zur Verfügung gestellt, einschließlich @Esko , mit der Arrays.toString und Arrays.deepToString Methoden, ist einfach das beste.

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

Im Folgenden werde ich versuchen, einige der anderen Methoden zur Liste vorgeschlagen, versuchen, ein wenig zu verbessern, mit der bemerkenswerteste Zusätzlich ist die Verwendung der Stream.collect Operator, ein joining Collector, zu imitieren, was die String.join tut.

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

Answer 8

Vor Java 8

Wir haben könnte verwendet Arrays.toString(array) eindimensionales Array und Arrays.deepToString(array) für mehrdimensionale Arrays zu drucken.

Java 8

Jetzt haben wir die Möglichkeit, Stream und lambda bekommen das Array zu drucken.

Drucken eindimensionales Array:

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 lautet:

  

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

Drucken mehrdimensionales Array Nur für den Fall wollen wir mehrdimensionales Array drucken wir Arrays.deepToString(array) als verwenden können:

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 beachten ist, dass das Verfahren Arrays.stream(T[]), die im Falle einer int[] uns Stream<int[]> zurückkehrt und dann ordnet Verfahren flatMapToInt() jedes Element des Stromes mit dem Inhalt eines zugeordneten Strom erzeugt, indem die vorgesehenen Abbildungsfunktion auf jedes Element angewendet wird.

Die Ausgabe lautet:

  

[[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

Answer 9

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

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

Um tatsächlich eine Tabelle als zweidimensionale Tabelle zu drucken, ich hatte dies zu tun:

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

Es scheint, wie die Arrays.deepToString(arr) Methode sollte einen Trenn-String nehmen, aber leider nicht.

Answer 10

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

Answer 11

Die verschiedenen Arrays in Java 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:       [Eines, Zwei, Drei, Vier]

2. Mit toString()

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

  

Ausgabe: [Eines, Zwei, Drei, Vier]

3. Druck Array von Arrays

   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], [siebten, achten]]

Resource: Zugang ein Array

Answer 12

Mit regelmäßiger für Schleife ist die einfachste Art des Druckarray meiner Meinung nach. Hier haben Sie einen Beispielcode auf der Grundlage Ihrer intArray

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

Es gibt Ausgang wie bei Ihnen     1, 2, 3, 4, 5

Answer 13

Ich kam in diesem Beitrag in Vanilla #Java vor kurzem. Es ist nicht sehr bequem Schreiben Arrays.toString(arr);, dann die ganze Zeit den Import java.util.Arrays;.

Bitte beachten Sie, dies ist keine dauerhafte Lösung mit allen Mitteln. Nur ein Hack, die einfacher machen debuggen.

ein Array Drucken gibt direkt die interne Darstellung und die hashCode. Nun haben alle Klassen als Elterntyp Object. Also, warum nicht den Object.toString() hackt? Ohne Änderung sieht die Objektklasse wie folgt:

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

Was ist, wenn dies geändert:

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 modded Klasse einfach zum Klassenpfad hinzugefügt werden können, die folgenden in der Befehlszeile durch Zugabe. -Xbootclasspath/p:target/classes

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

Ich fand das ein sehr nützlich Hack zu sein, und es wäre toll, wenn Java einfach diese hinzufügen könnte. Ich verstehe, potenzielle Probleme mit könnte problematisch sein, da die Stringdarstellungen sehr großen Arrays mit. Vielleicht so etwas wie ein System.outor eine PrintWriter für solche Fälle passieren.

Answer 14

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

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

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

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! zu sein, dies ist schon erwähnt, dass ein Array auf einen Objektarray Umwandlung oder das Objekts des Arrays ist kostspielig zu verwenden und die Ausführung verlangsamen kann. es geschieht durch die Natur von Java genannt Autoboxing.

So nur für einen bestimmten Zweck Druck, sollte es nicht verwendet werden. wir können eine Funktion machen, die ein Array als Parameter übernimmt und druckt das gewünschte Format wie

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

Answer 15

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

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

2. Methode Referenz: ::println

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

Wenn Sie alle Elemente im Array in der gleichen Zeile drucken, dann benutzen Sie einfach print statt println d

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

Eine andere Möglichkeit, ohne Methode Referenz nur verwenden:

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

Answer 16

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

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

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

druckt

abc

Answer 17

, um alle Antworten hinzuzufügen, Drucken des Objekts als ein JSON-String ist auch eine Option.

Mit Jackson:

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

Mit Gson:

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

Answer 18

Eine vereinfachte Verknüpfung Ich habe versucht, ist dies:

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

Es wird gedruckt

1
2
3

Keine Schleifen in diesem Ansatz erforderlich, und es ist am besten für kleines Arrays nur

Answer 19

könnten Sie Schleife durch das Array, jedes Element auszudrucken, wie Sie Schleife. 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

Answer 20

gibt es folgende Art und Weise Array

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

Answer 21

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

Answer 22

Mit org.apache.commons.lang3.StringUtils.join (*) Methoden 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

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

Answer 23

-jede Schleife kann auch verwendet werden Elemente des Arrays drucken:

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

Answer 24

Dies ist markiert als ein Duplikat für einen Druck byte [] . Hinweis: für eine Byte-Array gibt es weitere Methoden, die geeignet sind,

.

Sie können es als String 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 enthält einen UTF-8-String

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 hexadezimale wollen drucken.

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

oder wenn Sie es als base64 wollen drucken.

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

oder wenn Sie wollen eine Reihe von signierten Byte-Werte

drucken

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 wollen ein Array von unsigned Byte-Werte

drucken

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.

Answer 25

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

Answer 26

In Java 8:

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

Answer 27

Es gibt mehr Möglichkeiten, um einen Array elements.First alle zu drucken, ich erklären würde, was ein Array ist? .. Array ist eine einfache Datenstruktur zum Speichern von data..When Ihnen einen Array definieren, weist Satz von Hilfsspeicherblöcke in RAM.Those Speicherblöcke sind eine Einheit genommen ..

Ok, ich werde ein Array wie folgt erstellen,

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

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

           System.out.print(number);
      }
}

Jetzt am Ausgang suchen,

Sie können eine unbekannte Zeichenkette printed..As sehe ich schon erwähnt, die Speicheradresse, deren Array (Anzahl Array) deklariert ist printed.If Sie Elemente im Array angezeigt werden, können Sie „for-Schleife“, 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]+"  ");
           }
      }
}

Jetzt am Ausgang suchen,

Ok, Erfolgreich gedruckten Elemente einer Dimension array..Now ich zwei Dimensionen betrachten werde array..I'll zwei dimensionales Array als „number2“ deklarieren und die Elemente mit „Arrays.deepToString ()“ Stichwort drucken. Vor dem Einsatz, dass Sie müssen 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));
      }
}

die Ausgabe betrachten,

Zur gleichen Zeit, die Verwendung von zwei for-Schleifen können 2D-Elemente printed..Thank Sie werden!

Answer 28

wenn Sie mit jdk 8.

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]

Answer 29

Bei der Verwendung von Commons.Lang Bibliothek konnten 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}

Answer 30

Wenn Sie drucken möchten, Array-Inhalte wie zu beurteilen, dass Sie Arrays.toString verwenden

jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }

jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"

jshell>