Vraag Wat is de eenvoudigste manier om een ​​Java-array af te drukken?


In Java worden arrays niet genegeerd toString(), dus als u er een rechtstreeks probeert af te drukken, krijgt u de className + @ + de hexadecimaal van de hashCode van de array, zoals gedefinieerd door Object.toString():

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

Maar meestal willen we eigenlijk zoiets als [1, 2, 3, 4, 5]. Wat is de eenvoudigste manier om dat te doen? Hier zijn enkele voorbeeldinvoer en -uitvoer:

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


oorsprong


antwoorden:


Sinds Java 5 kun je gebruiken Arrays.toString(arr) of Arrays.deepToString(arr) voor arrays binnen arrays. Merk op dat de Object[] versie oproepen .toString() op elk object in de array. De output is zelfs gedecoreerd op de exacte manier waarop je het vraagt.

Voorbeelden:

Simple Array:

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

Output:

[John, Mary, Bob]

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

Output:

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

double Array:

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

Output:

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

Output:

[7, 9, 5, 1, 3 ]

2035
2018-01-03 20:48



Controleer altijd eerst de standaardbibliotheken. Proberen:

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

of als uw array andere arrays als elementen bevat:

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

304
2018-05-12 21:01



Dit is leuk om te weten, echter, als voor "controleer altijd eerst de standaardbibliotheken" Ik zou nooit de truc zijn tegengekomen Arrays.toString( myarray )

- omdat ik me concentreerde op het type myarray om te zien hoe dit te doen. Ik wilde het ding niet herhalen: ik wilde een eenvoudige oproep om het te laten lijken op wat ik zie in de Eclipse-foutopsporing en myarray.toString () deed het gewoon niet.

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

85
2018-02-06 23:35



In JDK1.8 kunt u aggregatiebewerkingen en een lambda-uitdrukking gebruiken:

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



Als u Java 1.4 gebruikt, kunt u in plaats daarvan:

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

(Dit werkt natuurlijk ook in 1,5+)


37
2017-12-23 18:51



Te beginnen met Java 8, zou men ook kunnen profiteren van de join() methode geboden door de String klasse om array-elementen, zonder de haakjes, af te drukken en gescheiden door een scheidingsteken naar keuze (dit is het spatieteken voor het onderstaande voorbeeld):

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

De output zal zijn "Hey there amigo!".


35
2017-10-05 19:13



Arrays.deepToString(arr) drukt alleen op één regel af.

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

Om een ​​tabel eigenlijk als een tweedimensionale tabel te laten afdrukken, moest ik dit doen:

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

Het lijkt erop dat het Arrays.deepToString(arr) methode moet een scheidingstekenreeks gebruiken, maar helaas niet.


27
2018-03-11 05:36



Arrays.toString

Als een direct antwoord, de oplossing geboden door verschillende, waaronder @Esko, de ... gebruiken Arrays.toString en Arrays.deepToString methoden, is gewoon de beste.

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

Hieronder probeer ik een aantal van de andere voorgestelde methoden te noemen, waarbij ik probeer een beetje te verbeteren, waarbij de meest opvallende toevoeging het gebruik van de Stream.collect operator, met behulp van een joining  Collector, na te bootsen wat de String.join doet.

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



Voorafgaand aan Java 8 hadden we kunnen gebruiken Arrays.toString(array) om een ​​dimensionale array en af ​​te drukken Arrays.deepToString(array) voor meerdimensionale matrices. We hebben de optie van Stream en lambda in Java 8 die ook kan worden gebruikt voor het afdrukken van de array.

Eén-dimensionale array afdrukken:

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

De uitvoer is:

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

Multi-dimensionale array afdrukken Voor het geval we de multidimensionale array willen afdrukken die we kunnen gebruiken Arrays.deepToString(array) als:

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

Nu is het punt om te observeren dat de methode Arrays.stream(T[]), wat in geval van int[] geeft ons terug Stream<int[]> en dan methode flatMapToInt() brengt elk element van de stream in kaart met de inhoud van een gemapte stream die wordt geproduceerd door de verstrekte toewijzingsfunctie op elk element toe te passen.

De uitvoer is:

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


23
2018-01-24 04:25