Quelle est la façon la 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'hexagone du hashCodetableau, 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 généralement, nous voudrions en fait quelque chose de plus [1, 2, 3, 4, 5]. Quelle est la façon la plus simple de procéder? 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 dans les tableaux. Notez que la Object[]version fait appel .toString()à 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));

  Production:

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

  Production:

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

• double Tableau:

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

  Production:

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

  Production:

  [7, 9, 5, 1, 3 ]

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

import java.util.Arrays;

Alors essaye:

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

C'est agréable à savoir, cependant, car pour "toujours vérifier les bibliothèques standard en premier", je ne serais jamais tombé sur l'astuce de Arrays.toString( myarray )

- depuis que je me concentrais sur le type de myarray pour voir comment faire cela. Je ne voulais pas avoir à répéter la chose: je voulais un appel facile pour le faire sortir similaire à 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é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
*/

À partir de Java 8, on pourrait également profiter de la join()méthode fournie par la classe String pour imprimer les éléments du tableau, sans les crochets, et séparés par un délimiteur de choix (qui est le caractère espace pour l'exemple illustré ci-dessous):

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

La sortie sera "Hey there amigo!".

Si vous utilisez Java 1.4, vous pouvez à la place:

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

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

Arrays.toString

Comme réponse directe, la solution fournie par plusieurs, dont @Esko , en utilisant les méthodes Arrays.toStringet Arrays.deepToString, est tout simplement la meilleure.

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

Ci-dessous, j'essaie d'énumérer certaines des autres méthodes suggérées, en essayant de s'améliorer un peu, l'ajout le plus notable étant l'utilisation de l' Stream.collectopérateur, en utilisant a , pour imiter ce que fait.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);

Avant Java 8

Nous aurions pu utiliser Arrays.toString(array)pour imprimer un tableau unidimensionnel et Arrays.deepToString(array)pour des tableaux multidimensionnels.

Java 8

Nous avons maintenant la possibilité Streamet lambdad'imprimer le tableau.

Impression d'un tableau unidimensionnel:

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
Mary
Bob

Impression d'un tableau multidimensionnel Au cas où nous souhaiterions imprimer un tableau multidimensionnel, nous pouvons l'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[]retour nous Stream<int[]>et ensuite la méthode flatMapToInt()mappe 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
Mary
Lee
Bob
Johnson

Arrays.deepToString(arr) imprime uniquement sur une seule ligne.

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

Pour obtenir une table à imprimer en tant que table à deux dimensions, je devais faire ceci:

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

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

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

Différentes façons d'imprimer des tableaux en Java:

1. 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]

2. En utilisant toString()

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

Sortie: [un, deux, trois, quatre]

3. Impression d'un tableau 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

À mon avis, l' utilisation de la boucle for régulière est le moyen le plus simple d'imprimer un tableau. Ici, vous avez un exemple de code basé sur votre intArray

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

Il donne la sortie comme la vôtre 1, 2, 3, 4, 5

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 simplifier le débogage.

L'impression d'un tableau donne directement la représentation interne et le hashCode. Maintenant, toutes les classes ont Objectcomme type parent. Alors, pourquoi ne pas pirater le Object.toString()? Sans modification, la classe Object ressemble à ceci:

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

Et si cela 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 ce qui suit à la ligne de commande: -Xbootclasspath/p:target/classes .

Maintenant, avec la disponibilité de deepToString(..)depuis Java 5, le toString(..)peut facilement être changé endeepToString(..) pour ajouter la prise en charge des tableaux qui contiennent d'autres tableaux.

J'ai trouvé que c'était un hack assez utile et ce serait génial si Java pouvait simplement l'ajouter. Je comprends les problèmes potentiels liés à la présence de très grands tableaux, car les représentations de chaînes peuvent être problématiques. Peut-être passer quelque chose comme un System.outou un PrintWriterpour de telles éventualités.

Il devrait toujours fonctionner quelle que soit la version JDK que vous utilisez:

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

Cela fonctionnera si le Arraycontient des objets. Si le Arraycontient des types primitifs, vous pouvez utiliser des classes wrapper au lieu de stocker directement la primitive sous la forme ..

Exemple:

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

Remplacez-le par:

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

Mise à jour :

Oui ! il faut mentionner que la conversion d'un tableau en un tableau d'objets OU 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 doit pas être utilisé. nous pouvons faire une fonction qui prend un tableau comme paramètre et imprime le format souhaité comme

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

En java 8, c'est facile. il y a deux mots clés

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

2. référence de méthode: ::println

   int[] 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 printau lieu de printlnie

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

Une autre façon, sans référence de méthode, utilisez simplement:

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

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

impressions

abc

Pour ajouter à toutes les réponses, l'impression de l'objet sous forme de chaîne JSON est également une option.

Utiliser Jackson:

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

Utilisation de Gson:

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

Vous pouvez parcourir le tableau en imprimant chaque élément en boucle. Par exemple:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

Production:

item 1
item 2
item 3

Il existe des moyens suivants pour imprimer le tableau

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

1
2
3

Aucune boucle requise dans cette approche et il est préférable pour les petits tableaux uniquement

La boucle For-each peut également être utilisée pour imprimer des éléments du tableau:

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

L'utilisation des 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>

Il s'agit d'un doublon pour l' impression d'un octet [] . Remarque: pour un tableau d'octets, il existe des méthodes supplémentaires qui peuvent être appropriées.

Vous pouvez l'imprimer en tant que 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 souhaitez imprimer un tableau de valeurs d'octets signés

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]

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

production:

[7,3,5,1,3]

En java 8:

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

Si vous utilisez la bibliothèque Commons.Lang , nous pourrions faire:

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

Production:

{1,2,3,4,5}
{John,Mary,Bob}

// Si vous imprimez l'adresse de l'élément de tableau sur la console en java.

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

Il existe plusieurs façons d'imprimer les éléments d'un tableau. Tout d'abord, je vais vous expliquer, qu'est-ce qu'un tableau? 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);
      }
}

Regardez maintenant 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 (tableau de nombres) déclaré est imprimé. Si vous souhaitez afficher des é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]+"  ");
           }
      }
}

Regardez maintenant la sortie,

Ok, Éléments imprimés avec succès d'un tableau à une dimension..Je vais maintenant considérer un tableau à deux dimensions..Je vais déclarer un tableau à deux dimensions comme "nombre2" et imprimer les éléments en utilisant le 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érez la sortie,

Dans le même temps, en utilisant deux pour les boucles, les éléments 2D peuvent être imprimés .. Merci!