Question Quel est le moyen le plus simple d'imprimer un tableau Java?


En Java, les tableaux ne remplacent pas toString(), donc si vous essayez d'en imprimer un directement, vous obtenez le className + @ + l'hex du hashCode du tableau, tel que défini par Object.toString():

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

Mais habituellement, nous voudrions quelque chose de plus comme [1, 2, 3, 4, 5]. Quelle est la manière la plus simple de le faire? Voici quelques exemples d'entrées et de sorties:

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


origine


Réponses:


Depuis Java 5, vous pouvez utiliser Arrays.toString(arr) ou Arrays.deepToString(arr) pour les tableaux dans les tableaux. Notez que le Object[] appels de version .toString() sur chaque objet dans le tableau. La sortie est même décorée exactement comme vous le demandez.

Exemples:

Simple tableau:

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

Sortie:

[John, Mary, Bob]

Tableau imbriqué:

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

Sortie:

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

double Tableau:

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

Sortie:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

int Tableau:

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

Sortie:

[7, 9, 5, 1, 3 ]

2035
2018-01-03 20:48



Vérifiez toujours les bibliothèques standard en premier. Essayer:

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

ou si votre tableau contient d'autres tableaux en tant qu'éléments:

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

304
2018-05-12 21:01



Il est bon de savoir, cependant, que pour "toujours vérifier les bibliothèques standard d'abord" je ne serais jamais tombé sur l'astuce de Arrays.toString( myarray )

- puisque je me concentrais sur le type de myarray pour voir comment faire ça. Je ne voulais pas devoir parcourir la chose: je voulais un appel facile pour que ça sorte comme je le vois dans le débogueur Eclipse et myarray.toString () ne le faisait pas.

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

85
2018-02-06 23:35



Dans JDK1.8, vous pouvez utiliser des opérations d'agrégation et une expression lambda:

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



Si vous utilisez Java 1.4, vous pouvez plutôt faire:

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

(Cela fonctionne aussi en 1.5+, bien sûr.)


37
2017-12-23 18:51



A partir de Java 8, on pourrait aussi profiter du join() méthode fournie par le Classe de corde pour imprimer les éléments du tableau, sans les parenthèses, et séparés par un délimiteur de choix (qui est le caractère d'espace pour l'exemple ci-dessous):

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

La sortie sera "Hey there amigo!".


35
2017-10-05 19:13



Arrays.deepToString(arr) imprime seulement sur une ligne.

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

Pour réellement obtenir une table à imprimer en tant que tableau bidimensionnel, je devais faire ceci:

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

Il semble que le Arrays.deepToString(arr) méthode devrait prendre une chaîne de séparation, mais malheureusement, ce n'est pas le cas.


27
2018-03-11 05:36



Arrays.toString

En réponse directe, la solution fournie par plusieurs, y compris @Esko, en utilisant le Arrays.toString et Arrays.deepToString méthodes, est simplement le meilleur.

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

Ci-dessous, j'essaie d'énumérer quelques-unes des autres méthodes suggérées, en essayant d'améliorer un peu, avec l'ajout le plus notable étant l'utilisation de la Stream.collect opérateur, en utilisant un joining  Collector, pour imiter ce que le String.join fait.

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



Avant Java 8, nous aurions pu utiliser Arrays.toString(array) pour imprimer un tableau à une dimension et Arrays.deepToString(array) pour les tableaux multidimensionnels. Nous avons l'option de Stream et lambda en Java 8 qui peut également être utilisé pour l'impression du tableau.

Impression une matrice dimensionnelle:

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

La sortie est:

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

Impression de tableaux multidimensionnels Juste au cas où nous voulons imprimer un tableau multidimensionnel, nous pouvons utiliser Arrays.deepToString(array) comme:

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

Maintenant, le point à observer est que la méthode Arrays.stream(T[]), qui en cas de int[] nous renvoie Stream<int[]> et ensuite la méthode flatMapToInt() met en correspondance chaque élément de flux avec le contenu d'un flux mappé produit en appliquant la fonction de mappage fournie à chaque élément.

La sortie est:

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


23
2018-01-24 04:25



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

17
2017-08-07 14:05