Quelle est la façon la plus simple d'imprimer un tableau Java?


1946

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]

8
Que voulez-vous que la représentation soit pour des objets autres que des chaînes? Le résultat de l'appel à toString? Entre guillemets ou pas?
Jon Skeet

3
Oui, les objets seraient représentés par leur méthode toString () et sans guillemets (juste édité l'exemple de sortie).
Alex Spurling le

2
En pratique, étroitement lié à stackoverflow.com/questions/29140402/…
Raedwald

1
Cette sortie bizarre n'est pas nécessairement l'emplacement de la mémoire. C'est l' hashCode()hexadécimal. Tu vois Object#toString().
4castle

1
Pour imprimer un tableau unidimensionnel ou multidimensionnel dans java8, consultez stackoverflow.com/questions/409784/…
akhil_mittal

Réponses:


2606

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 ]

3
Et si nous avons un tableau de chaînes et que nous voulons une sortie simple; comme: String[] array = {"John", "Mahta", "Sara"}et nous voulons que cette sortie sans support et des virgules: John Mahta Sara?
Hengameh

3
@Hengameh: Il existe plusieurs autres façons de le faire, mais mon préféré est celui-ci: javahotchocolate.com/notes/java.html#arrays-tostring .
Russ Bateman

5
Pour info, Arrays.deepToString()accepte uniquement un Object [](ou un tableau de classes qui s'étendent Object, par exemple Integer, donc il ne fonctionnera pas sur un tableau de type primitif int []. Mais Arrays.toString(<int array>)fonctionne très bien pour les tableaux primitifs.
Marcus

4
@Hengameh Il existe une méthode dédiée à cela. System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))va imprimer John Mahta Sara.
user8397947

2
@dorukayhan En fait, vous pouvez omettre explicitement l'instanciation du tableau ici: String.join(" ", "John", "Mahta", "Sara")car la .join(...)méthode prend le tableau comme paramètre vararg .
Amadán

354

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

Et si nous avons un tableau de chaînes et que nous voulons une sortie simple; comme: String[] array = {"John", "Mahta", "Sara"}et nous voulons que cette sortie sans support et des virgules: John Mahta Sara?
Hengameh

1
@Hengameh Il suffit de stocker Arrays.toString (tableau) dans une variable de chaîne, puis de supprimer les accolades en remplaçant la méthode de Java
Naveed Ahmad

12
@Hengameh De nos jours avec Java 8: String.join(" ", Arrays.asList(array)). doc
Justin

106

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

Et si nous avons un tableau de chaînes et que nous voulons une sortie simple; comme: String[] array = {"John", "Mahta", "Sara"}et nous voulons que cette sortie sans support et des virgules: John Mahta Sara?
Hengameh

3
@Hengameh Je pense que c'est un autre sujet. Vous pouvez ensuite manipuler cette chaîne avec les opérations de chaîne courantes ... Comme Arrays.toString (myarray) .replace ("[", "("); et ainsi de suite.
OddDev

91

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

50
Ou moins encombrant,Arrays.stream(strArray).forEach(System.out::println);
Alexis C.

9
C'est maladroit. Il doit s'agir d' System.out::printlnune référence de méthode Java 8. Votre code produit un lambda inutile.
Boris the Spider

2
Il suffit de sauter le Arrays.asListet faitesArrays.stream(strArray).forEach(System.out::println)
Justin

1
@AlexisC. Parce qu'il peut également être utilisé avec d'autres objets que des tableaux.
Yassin Hajaj

1
@YassinHajaj Both. Par exemple, si vous voulez avoir un flux de plage sur le tableau, la manière idiomatique d'utiliser Stream.ofserait de le faire .skip(n).limit(m). L'implémentation actuelle ne renvoie pas de flux SIZED, contrairement à ce qui se Arrays.stream(T[], int, int)produit, ce qui entraîne une meilleure répartition des performances si vous souhaitez effectuer des opérations en parallèle. De plus, si vous en avez un int[], vous pouvez accidentellement utiliser Stream.ofce qui retournera un Stream<int[]>avec un seul élément, tout Arrays.streamen vous donnant IntStreamdirectement un .
Alexis C.

41

À 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!".


40

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


38
Malheureusement, cela ne fonctionne qu'avec des tableaux d'objets, pas avec des tableaux de primitives.
Alex Spurling le

34

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

33

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


Et si nous avons un tableau de chaînes et que nous voulons une sortie simple; comme: String[] array = {"John", "Mahta", "Sara"}et nous voulons que cette sortie sans support et des virgules: John Mahta Sara?
Hengameh

28

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.


3
Peut-être utiliser System.getProperty ("line.separator"); au lieu de \ r \ n, il convient donc également aux non-Windows.
Scooter

vous pouvez utiliser System.lineSeparator () maintenant
Novaterata

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

6
De cette façon, vous vous retrouvez avec un espace vide;)
Matthias

1
@ matthiad .. cette ligne évitera de se retrouver avec un espace vide System.out.println (n + (someArray.length == n)? "": "");
Muhammad Suleman

3
La pire façon de le faire.
NameNotFoundException

@MuhammadSuleman Cela ne fonctionne pas, car il s'agit d'une boucle pour chaque. nest la valeur réelle du tableau, pas l'index. Pour une boucle for régulière, ce serait également le cas (someArray.length - 1) == i, car elle casse lorsque iest égal à la longueur du tableau.
Radiodef

17

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]

  1. En utilisant toString()

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

Sortie: [un, deux, trois, quatre]

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


13

À 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


4
Il imprime "1, 2, 3, 4, 5" en sortie, il imprime aussi une virgule après le dernier élément.
icza

Quelle est la solution pour ne pas avoir de virgule après le dernier élément?
Mona Jalal

3
Vous pouvez remplacer le code dans la boucle parSystem.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
Nepoxx

2
Vous pouvez également utiliser System.out.print(i + (i < intArray.length - 1 ? ", " : ""));pour combiner ces deux lignes.
Nick Suwyn

Vous pouvez utiliser un StringBuilder et tronquer la virgule de fin. int [] intArray = new int [] {1, 2, 3, 4, 5}; final StringBuilder sb = new StringBuilder (); for (int i: intArray) {sb.append (intArray [i]). append (","); } if (sb.length ()> 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); Cela produit "1, 2, 3, 4, 5".
Rick Ryker du

8

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.


2
vous souhaitez exécuter ces ifconditions sur chaque objet?
sidgate

+1 juste pour l'idée, mais sur la base des commentaires précédents, pouvons-nous modifier directement les implémentations du tableau plutôt que de dépendre du Objectparent commun? Pouvons-nous approfondir cette idée? Non pas que je pense que modifier le comportement par défaut des objets java.lang. * Est quelque chose que j'encouragerais ...
YoYo

8

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
} 

1
Convertir un tableau en liste simplement à des fins d'impression ne semble pas être une décision très ingénieuse; et étant donné que la même classe a un toString(..), ça me bat pourquoi quelqu'un ferait jamais ça.
Debosmit Ray

8

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

1
Cela imprimera chaque élément du tableau sur une ligne distincte afin qu'il ne réponde pas aux exigences.
Alex Spurling

si vous voulez imprimer tous les éléments du tableau sur la même ligne, utilisez simplement print au lieu de println, c'est-à-dire int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (intArray) .forEach (System.out :: print); dans le cas contraire sans référence de méthode, utilisez simplement int [] intArray = new int [] {1, 2, 3, 4, 5}; System.out.println (Arrays.toString (intArray));
suatCoskun

6

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

5

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

C'est ce que je fais. Avec cela, vous pouvez imprimer des structures arbitrairement complexes tant qu'elles sont encodables en JSON. Je m'assure toujours d'utiliser "jolie". Votre deuxième exemple fait-il cela? Je pense que vous auriez besoin de chatouiller une "jolie" option pour l'obtenir.
Steve

5

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

5

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

4

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


4

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

@firephil System.out.println (a [i]); est utilisé avec la boucle for ordinaire, où l'index "i" est créé et la valeur à chaque index est imprimée. J'ai utilisé la boucle "pour chaque". Essayez, j'espère que vous comprendrez mon point.
hasham.98

Oui, c'est le moyen le plus court d'imprimer un tableau
Manjitha teshara

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

3

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>

Ajouter une dépendance à cause de quelque chose de trivial qui se fait en deux lignes de code est un antipattern hurlant.
jurez

commons-lang3 est une dépendance très peuplière, et notez que cette réponse était que la plupart des gens n'avaient pas utilisé java 8
Haim Raman

2

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.

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

1

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]

C'est mieux que la réponse acceptée en ce qu'elle donne plus de contrôle sur le délimiteur, le préfixe et le suffixe. Cependant, je supprimerais superflu toString()dans la finale System.out.println()et l'utiliserais au joiner.add(element.toString())lieu d'ajouter la chaîne vide. Cette solution fonctionne également pour les tableaux de types non primitifs.
John McClane

Mon mauvais, à l' element.toString()intérieur joiner.add()est réservé aux types non primitifs. Vous devez toujours utiliser des Integer.toString(element)constructions similaires à celles des types primitifs. Personnellement, j'ai utilisé foreach loop for (int element : array) joiner.add(Integer.toString(element));au lieu de streams, mais c'est une question de goût.
John McClane

0

En java 8:

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

0

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}

0

// 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 + "");

Cela ne semble pas répondre à la question.
utilisateur

-1

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,

entrez la description de l'image ici

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,

entrez la description de l'image ici

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,

entrez la description de l'image ici

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


int array [] = {1, 2, 3, 4, 5}; pour (int i: array) System.out.println (i);
Manjitha teshara

essayez ceci, je pense que c'est le moyen le plus court pour imprimer le tableau
Manjitha teshara

"l'adresse mémoire dont le tableau (tableau de nombres) déclaré est imprimé" Ce n'est pas vrai du tout, son code de hachage système de l'objet, et cela peut être basé sur beaucoup de choses, y compris l'adresse mémoire, mais cela pourrait changer plus tard et le code de hachage ne serait pas changement. Et actuellement, c'est principalement un nombre aléatoire. gotofinal.dev/java/2017/10/08/java-default-hashcode.html
GotoFinal
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.