Comment afficher un tableau en Java

Passer un tableau directement à System.out.println n'affiche presque jamais ce que vous attendez — vous obtenez quelque chose comme [I@1b6d3586 au lieu des éléments. Les tableaux ne redéfinissent pas toString(), donc la version par défaut d'Object affiche le type et un hash d'identité. Ce chapitre présente les solutions idiomatiques : Arrays.toString pour les tableaux plats, Arrays.deepToString pour les tableaux imbriqués, String.join pour les délimiteurs personnalisés, et une boucle manuelle quand vous avez besoin d'un contrôle total.

Pourquoi un affichage simple échoue

Le toString() par défaut qu'un tableau hérite d'Object renvoie une signature de classe suivie d'un code de hachage — pas le contenu :

int[] numbers = {3, 1, 4};
System.out.println(numbers);       // [I@1b6d3586
System.out.println("" + numbers);  // same reference string

[I signifie « tableau d'int » ; l'hexadécimal après @ est le hash d'identité, qui change entre les exécutions. Concaténer le tableau dans une chaîne n'aide pas, car la concaténation appelle également toString(). La solution consiste à demander à un utilitaire de formater les éléments à votre place.

Arrays.toString pour une dimension

java.util.Arrays.toString parcourt un tableau à une seule dimension et renvoie une chaîne lisible, séparée par des virgules, entre crochets :

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

String[] words = {"alpha", "beta"};
System.out.println(Arrays.toString(words));   // [alpha, beta]

Elle est surchargée pour chaque type de tableau primitif (int[], double[], boolean[], …) et pour Object[], donc elle fonctionne sur n'importe quel tableau plat que vous lui passez. Pour les tableaux d'objets, elle appelle le propre toString() de chaque élément.

Arrays.deepToString pour les tableaux imbriqués

Arrays.toString ne descend qu'à un seul niveau. Sur un tableau 2D, elle formate le tableau externe mais affiche chaque tableau interne comme une référence. Utilisez Arrays.deepToString pour récurser à travers tous les niveaux :

int[][] grid = {{1, 2}, {3, 4}};
System.out.println(Arrays.toString(grid));     // [[I@..., [I@...]
System.out.println(Arrays.deepToString(grid)); // [[1, 2], [3, 4]]

Utilisez deepToString dès que le tableau contient d'autres tableaux — matrices, tableaux irréguliers, tableaux de tableaux d'objets.

Approche	Idéale pour	Style de sortie
`Arrays.toString`	Tableaux primitifs ou d'objets 1D	`[a, b, c]`
`Arrays.deepToString`	Tableaux imbriqués / multidimensionnels	`[[a, b], [c, d]]`
`String.join`	`String[]` avec un délimiteur personnalisé	`a, b, c` (sans crochets)
boucle manuelle / `StringBuilder`	Contrôle total du format	tout ce que vous construisez

Formatage personnalisé

Quand le format entre crochets par défaut ne convient pas, String.join joint un String[] (ou tout itérable CharSequence) avec le délimiteur de votre choix et sans crochets :

String[] words = {"alpha", "beta", "gamma"};
System.out.println(String.join(" | ", words)); // alpha | beta | gamma

Pour les tableaux non-string ou une sortie entièrement personnalisée, une boucle avec un StringBuilder vous donne un contrôle total sur les séparateurs, les préfixes et le formatage par élément. Les flux sont une autre option : Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(", ")).

Un exemple exécutable

Le programme ci-dessous compare les approches : Arrays.toString sur un int[] et un String[] plats, la différence superficiel-vs-profond sur un tableau 2D, String.join pour un délimiteur personnalisé, et un StringBuilder construit à la main. La ligne shallow vérifie si le toString superficiel du tableau 2D contient encore des références internes, elle affiche donc un true stable plutôt qu'un hash variable d'une exécution à l'autre.

java— editable, runs on the server

import java.util.Arrays;

public class ArrayPrinter {
    public static void main(String[] args) {
        int[] numbers = {3, 1, 4, 1, 5};

// Arrays.toString is the standard way for a one-dimensional array.
        System.out.println("toString: " + Arrays.toString(numbers));

String[] words = {"alpha", "beta", "gamma"};
        System.out.println("words: " + Arrays.toString(words));

// For a nested array, toString prints inner references; deepToString recurses.
        int[][] grid = {{1, 2}, {3, 4}};
        System.out.println("shallow: " + Arrays.toString(grid).startsWith("[[I@"));
        System.out.println("deep: " + Arrays.deepToString(grid));

// String.join builds a custom-delimited line from a String array.
        System.out.println("joined: " + String.join(" | ", words));

// A manual loop gives full control over the format.
        StringBuilder sb = new StringBuilder("{");
        for (int i = 0; i < numbers.length; i++) {
            sb.append(numbers[i]);
            if (i < numbers.length - 1) {
                sb.append("; ");
            }
        }
        sb.append("}");
        System.out.println("manual: " + sb);
    }
}

Ce que l'exécution nous apprend :

toString: [3, 1, 4, 1, 5] montre Arrays.toString transformant un int[] plat en texte lisible entre crochets.
words: [alpha, beta, gamma] confirme que la même méthode fonctionne sur les tableaux d'objets en appelant le toString() de chaque élément.
shallow: true prouve que Arrays.toString appliqué à un tableau 2D laisse les tableaux internes comme des références [[I@..., c'est pourquoi le résultat commence par [[I@.
deep: [[1, 2], [3, 4]] montre Arrays.deepToString récursant dans les tableaux imbriqués pour afficher chaque élément.
joined: alpha | beta | gamma et manual: {3; 1; 4; 1; 5} montrent String.join et une boucle StringBuilder produisant une sortie sans crochets avec des délimiteurs personnalisés.

Pratique

Que affiche Arrays.toString(grid) quand grid est un tableau int bidimensionnel comme {{1, 2}, {3, 4}}?

Il affiche le tableau externe mais montre chaque tableau interne comme une référence telle que [I@..., donc vous avez besoin de Arrays.deepToString pour le contenu complet.Il affiche le contenu entièrement imbriqué [[1, 2], [3, 4]] exactement comme deepToString.Il lève une exception car toString n'accepte que les tableaux à une dimension.Il affiche une liste aplatie [1, 2, 3, 4] sans imbrication.