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 + @ + le numéro hexadécimal du hashCode du tableau, 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 en réalité quelque chose de plus semblable à [1, 2, 3, 4, 5]. Quel est le moyen le 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]
Depuis Java 5, vous pouvez utiliser Arrays.toString(arr) ou Arrays.deepToString(arr) pour les tableaux au sein des tableaux. Notez que la version Object[] appelle .toString() sur chaque objet du tableau. La sortie est même décorée de la manière exacte que vous demandez.
Exemples:
Tableau simple:
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]]doubleTableau: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 ]intTableau:int[] intArray = { 7, 9, 5, 1, 3 }; System.out.println(Arrays.toString(intArray));Sortie:
[7, 9, 5, 1, 3 ]
Toujours vérifier d'abord les bibliothèques standard. 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));
Cela fait plaisir à savoir, cependant, car pour "toujours vérifier les bibliothèques standard en premier", je ne serais jamais tombé sur le truc de Arrays.toString( myarray )
- Depuis que je me suis concentré sur le type de myarray pour voir comment faire cela. Je ne voulais pas avoir à parcourir la chose: je voulais un appel simple pour le faire ressembler à ce que je vois dans le débogueur Eclipse et myarray.toString () ne le faisait tout simplement pas.
import Java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
Dans JDK1.8, vous pouvez utiliser des opérations d'agrégat 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
*/
Si vous utilisez Java 1.4, vous pouvez plutôt faire:
System.out.println(Arrays.asList(array));
(Cela fonctionne dans 1.5+ aussi, bien sûr.)
À partir de Java 8, on pourrait également tirer parti de la méthode join() fournie par la classe String pour imprimer des éléments de tableau, sans les crochets et séparés par un délimiteur de choix (le caractère espace de l'exemple présenté). au dessous de):
String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting)
Le résultat sera "Hey there amigo!".
Arrays.toString
En réponse directe, la solution proposée par plusieurs méthodes, notamment @Esko , en utilisant les méthodes Arrays.toString et Arrays.deepToString , est tout simplement la meilleure.
Java 8 - Stream.collect (join ()), Stream.forEach
J'essaie ci-dessous de répertorier certaines des autres méthodes suggérées, en essayant d'améliorer un peu, en ajoutant l'utilisation la plus notable de l'opérateur Stream.collect , à l'aide de joiningCollector, pour imiter ce que le String.join est Faire.
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) imprime uniquement sur une ligne.
int[][] table = new int[2][2];
Pour obtenir un tableau à imprimer en tant que tableau à deux dimensions, je devais faire ceci:
System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));
Il semble que la méthode Arrays.deepToString(arr) devrait prendre une chaîne de séparation, mais malheureusement pas.
Avant Java 8
Nous aurions pu utiliser Arrays.toString(array) pour imprimer un tableau à une dimension et Arrays.deepToString(array) pour des tableaux multidimensionnels.
Java 8
Nous avons maintenant l'option Stream et lambda pour imprimer le tableau.
Impression tableau à une dimension:
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 d’un tableau multidimensionnel Si 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);
}
À présent, il convient de noter que la méthode Arrays.stream(T[]), qui dans le cas de int[] nous renvoie Stream<int[]>, puis que la méthode flatMapToInt() mappe chaque élément du 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
for(int n: someArray) {
System.out.println(n+" ");
}
Différentes façons d’imprimer des tableaux en Java:
Manière simple
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);
Sortie: [Un deux trois quatre]
Utilisation de
toString()String[] array = new String[] { "One", "Two", "Three", "Four" }; System.out.println(Arrays.toString(array));
Sortie: [Un, Deux, Trois, Quatre]
Tableau d'impression de tableaux
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));
Sortie: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Cinquième, Sixième], [Septième, Huitième]]
Ressource: Accéder à un tableau
Utiliser la boucle normale pour est la manière la plus simple d’imprimer un tableau, à mon avis ..____.
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + ", ");
}
Il donne une sortie comme la tienne 1, 2, 3, 4, 5
Cela devrait toujours fonctionner quelle que soit la version de JDK que vous utilisez:
System.out.println(Arrays.asList(array));
Cela fonctionnera si la Array contient des objets. Si la variable Array contient des types primitifs, vous pouvez utiliser des classes wrapper au lieu de stocker la primitive directement en tant que ..
Exemple:
int[] a = new int[]{1,2,3,4,5};
Remplacez-le par:
Integer[] a = new Integer[]{1,2,3,4,5};
Mettre à jour :
Oui ! il est à noter que la conversion d'un tableau en un tableau d'objets OR pour utiliser le tableau d'objets est coûteuse et peut ralentir l'exécution. cela se produit par la nature de Java appelée autoboxing.
Donc, uniquement à des fins d'impression, il ne devrait pas être utilisé. nous pouvons faire une fonction qui prend un tableau en paramètre et affiche le format souhaité
public void printArray(int [] a){
//write printing code
}
En Java 8, c'est facile. il y a deux mots-clés
- flux:
Arrays.stream(intArray).forEach référence de la méthode:
::printlnint[] intArray = new int[] {1, 2, 3, 4, 5}; Arrays.stream(intArray).forEach(System.out::println);
Si vous souhaitez imprimer tous les éléments du tableau sur la même ligne, utilisez simplement print au lieu de println i.e.
int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);
Une autre manière sans référence à la méthode consiste simplement à utiliser:
int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));
Je suis tombé sur ce post dans Vanilla #Java récemment. Ce n'est pas très pratique d'écrire Arrays.toString(arr);, puis d'importer Java.util.Arrays; tout le temps.
Veuillez noter qu'il ne s'agit en aucun cas d'une solution permanente. Juste un hack qui peut rendre le débogage plus simple.
L'impression d'un tableau donne directement la représentation interne et le hashCode. Maintenant, toutes les classes ont Object comme type parent. Alors, pourquoi ne pas pirater la Object.toString()? Sans modification, la classe Object ressemble à ceci:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Et si ceci est changé en:
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());
}
Cette classe modded peut simplement être ajoutée au chemin de classe en ajoutant les éléments suivants à la ligne de commande: -Xbootclasspath/p:target/classes.
Désormais, avec la disponibilité de deepToString(..) depuis Java 5, il est facile de remplacer toString(..) par deepToString(..) afin d'ajouter la prise en charge des baies contenant d'autres baies.
J'ai trouvé que c'était un hack très utile et ce serait formidable si Java pouvait simplement l'ajouter. Je comprends les problèmes potentiels liés aux très grands tableaux, car les représentations de chaîne pourraient poser problème. Peut-être transmettre quelque chose comme un System.outou une PrintWriter pour de telles éventualités.
Pour ajouter à toutes les réponses, l'impression de l'objet sous forme de chaîne JSON est également une option.
En utilisant Jackson:
ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));
Utiliser Gson:
Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));
Il existe un moyen supplémentaire si votre tableau est de type char []:
char A[] = {'a', 'b', 'c'};
System.out.println(A); // no other arguments
empreintes
abc
Il y a plusieurs manières d'imprimer Array
// 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);
}
Voici un raccourci simplifié que j'ai essayé:
int x[] = {1,2,3};
String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
System.out.println(printableText);
Il va imprimer
1
2
3
Aucune boucle requise dans cette approche et il est préférable de ne l'utiliser que pour les petits tableaux
Vous pouvez parcourir le tableau en imprimant chaque élément au fur et à mesure. Par exemple:
String[] items = {"item 1", "item 2", "item 3"};
for(int i = 0; i < items.length; i++) {
System.out.println(items[i]);
}
Sortie:
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);
}
}
}
Utiliser les méthodes org.Apache.commons.lang3.StringUtils.join (*) peut être une option
Par exemple:
String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]
J'ai utilisé la dépendance suivante
<groupId>org.Apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
For-each loop peut également être utilisé pour imprimer des éléments de tableau:
int array[] = {1, 2, 3, 4, 5};
for (int i:array)
System.out.println(i);
Ceci est marqué comme un doublon pour imprimer un octet [] . Remarque: pour un tableau d'octets, il existe des méthodes supplémentaires qui peuvent être appropriées.
Vous pouvez l’imprimer sous forme de chaîne s’il contient des caractères ISO-8859-1.
String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);
ou s'il contient une chaîne UTF-8
String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);
ou si vous voulez l'imprimer en hexadécimal.
String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);
ou si vous voulez l’imprimer en base64.
String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);
ou si vous voulez imprimer un tableau de valeurs d'octets signées
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]);
ou si vous souhaitez imprimer un tableau de valeurs d'octets non signés
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]
Il existe plusieurs manières d’imprimer un élément de tableau.Tout d’abord, je vais expliquer ce qu’est un tableau? .. Le tableau est une simple structure de données permettant de stocker des données. Lorsque vous définissez un tableau, allouez un ensemble de blocs de mémoire auxiliaires. en RAM.Ces blocs de mémoire sont pris une unité ..
Ok, je vais créer un tableau comme celui-ci,
class demo{
public static void main(String a[]){
int[] number={1,2,3,4,5};
System.out.print(number);
}
}
Maintenant, regardez la sortie,
Vous pouvez voir une chaîne inconnue imprimée..Comme je l'ai mentionné précédemment, l'adresse mémoire dont le tableau (nombre tableau) déclaré est imprimé.Si vous souhaitez afficher les éléments dans le tableau, vous pouvez utiliser "for loop", comme ceci ..
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]+" ");
}
}
}
Maintenant, regardez la sortie,
Ok, Éléments imprimés avec succès d'un tableau de dimensions..Maintenant, je vais considérer un tableau de deux dimensions..Je vais déclarer un tableau de deux dimensions en tant que "nombre2" et imprimer les éléments à l'aide du mot-clé "Arrays.deepToString ()". Vous devrez importer la bibliothèque 'Java.util.Arrays'.
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));
}
}
considérer la sortie,
En même temps, en utilisant deux boucles for, des éléments 2D peuvent être imprimés. Merci!
En Java 8:
Arrays.stream(myArray).forEach(System.out::println);
si vous utilisez 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);
sortie:
[7,3,5,1,3]