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




taille tableau java (22)

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, comme défini par Object.toString() :

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

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]

L'utilisation régulière pour la boucle est le moyen le plus simple d'impression de tableau à mon avis. 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 en tant que vôtre 1, 2, 3, 4, 5


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

  1. stream: 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 voulez imprimer tous les éléments du tableau dans la même ligne, utilisez simplement print au lieu de println ie

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 suffit d'utiliser:

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

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

  1. Simple Way

    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]

  1. Utilisation de toString()

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

Sortie: [Un, Deux, Trois, Quatre]

  1. Impression de tableaux 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


Pour chaque boucle 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);

Depuis Java 5, vous pouvez utiliser Arrays.toString(arr) ou Arrays.deepToString(arr) pour les tableaux dans les tableaux. Notez que la version Object[] appelle .toString() sur chaque objet du 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 Array:

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

Sortie:

[7, 9, 5, 1, 3 ]

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

}

Sortie:

item 1
item 2
item 3

En java 8:

Arrays.stream(myArray).forEach(element-> System.out.println(element));

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

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(int n: someArray) {
    System.out.println(n+" ");
}

Vous pouvez utiliser Arrays.toString()

String[] array = { "a", "b", "c" };  
System.out.println(Arrays.toString(array));

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

En utilisant Jackson:

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

En utilisant Gson:

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

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

Je suis tombé sur ce post dans Vanilla #Java récemment. Ce n'est pas très pratique d'écrire Arrays.toString(arr); , puis en important java.util.Arrays; tout le temps.

S'il vous plaît noter, ce n'est pas une solution permanente par tous les moyens. Juste un hack qui peut simplifier le débogage.

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

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

Et si ceci est changé pour:

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 la 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é en deepToString(..) pour ajouter du support pour les tableaux qui contiennent d'autres tableaux.

J'ai trouvé que c'était un hack très utile et ce serait génial si Java pouvait simplement ajouter ceci. Je comprends les problèmes potentiels avec des tableaux très volumineux, car les représentations sous forme de chaînes peuvent être problématiques. Peut-être passer quelque chose comme un System.out ou un PrintWriter pour de telles éventualités.


Il y a un moyen supplémentaire si votre tableau est de type char []:

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

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

imprime

abc

Il y a la façon suivante 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(Integer lists : arrayInt){
         System.out.println(lists);
     }

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

Le moyen le plus simple d'imprimer un tableau est d'utiliser une boucle for:

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

Arrays.deepToString(arr) imprime uniquement 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 la Arrays.deepToString(arr) prenne une chaîne de séparation, mais malheureusement, elle ne le fait pas.


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

En commençant par Java 8, on pourrait aussi profiter de la méthode join() fournie par la classe String 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!".


Arrays.toString

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

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

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






printing