Tableaux en Java : déclarer, initialiser, accéder et parcourir

Un tableau est une liste de taille fixe

Un tableau en Java contient un nombre fixe de valeurs du même type, disposées dans l'ordre et accessibles par leur position. « Fixe » est le mot clé : une fois que vous créez un tableau, sa longueur ne change jamais. Et « même type » : un int[] ne contient que des valeurs int, un String[] ne contient que des chaînes. Cette rigidité est le prix à payer pour que les tableaux soient rapides et compacts en mémoire.

Vous déclarez un type de tableau en plaçant [] après le type de l'élément, puis vous affectez un littéral ou en allouez un avec new :

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};
        String[] names = {"Ada", "Boris", "Chen"};

        System.out.println(scores[0]);
        System.out.println(names[1]);
    }
}

Les crochets peuvent se placer après le type (int[] scores) ou après le nom (int scores[]). Les deux compilent, mais int[] scores est le style idiomatique en Java - mettez les [] avec le type, là où ils doivent être.

Créer un tableau avec new

Quand vous ne connaissez pas encore les valeurs mais que vous connaissez la taille, utilisez new. Cela alloue les cases et les remplit avec la valeur par défaut du type :

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        boolean[] flags = new boolean[3];
        String[] words = new String[2];

        System.out.println(nums[0]);
        System.out.println(flags[0]);
        System.out.println(words[0]);
    }
}

Les valeurs par défaut ne sont pas du contenu aléatoire - Java initialise chaque élément à zéro. Les types numériques commencent à 0 (ou 0.0), boolean commence à false, et les types référence comme String commencent à null. Ce null mérite qu'on s'en souvienne : un String[] fraîchement alloué est rempli de null, et appeler une méthode sur l'un d'eux lève une NullPointerException.

L'indexation commence à zéro

Vous lisez et écrivez les éléments par indice, en comptant à partir de 0. Le dernier indice valide est toujours length - 1 :

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        System.out.println(colors[0]);
        System.out.println(colors[2]);

        colors[1] = "yellow";
        System.out.println(colors[1]);
    }
}

Contrairement aux tableaux de certains langages de script, sortir des limites ne vous renvoie pas discrètement null ou undefined - cela lève une exception. Essayez de lire un indice qui n'existe pas :

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};
        System.out.println(nums[5]);
    }
}

Ce programme plante avec :

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 3

C'est l'une des erreurs les plus courantes chez les débutants. La correction est presque toujours une erreur d'un cran (off-by-one) dans la condition d'une boucle - utiliser <= là où vous vouliez <.

length est un champ, pas une méthode

Chaque tableau porte sa taille dans un champ length. Attention : pas de parenthèses.

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40};
        System.out.println(nums.length);
    }
}

Voici un piège qui attrape tout le monde au moins une fois : les tableaux utilisent .length (un champ), mais String utilise .length() (une méthode). Écrire nums.length() sur un tableau est une erreur de compilation, et écrire text.length sur une chaîne l'est aussi. Le même mot, des règles différentes - celui du tableau n'a pas de parenthèses.

Parcourir un tableau

Vous avez appris la boucle for-each à la page précédente, et c'est la façon la plus propre de lire chaque élément quand vous n'avez pas besoin de l'indice :

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};

        int total = 0;
        for (int score : scores) {
            total += score;
        }

        System.out.println("Total: " + total);
        System.out.println("Average: " + (total / scores.length));
    }
}

Quand vous avez besoin de l'indice - pour afficher des numéros de position, modifier des éléments sur place ou itérer à l'envers - tournez-vous vers la classique boucle for indexée, avec length comme borne :

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};

        for (int i = 0; i < names.length; i++) {
            System.out.println(i + ": " + names[i]);
        }
    }
}

La condition est i < names.length, pas <=. Utiliser <= va un cran trop loin et lève l'exception de dépassement de limites vue dans la section précédente. Une règle rapide : for-each quand vous ne faites que lire des valeurs, for indexée quand vous avez besoin de la position ou que vous voulez réécrire dans le tableau.

Tableaux multidimensionnels

Un tableau 2D est en réalité un tableau de tableaux - voyez-le comme une grille de lignes et de colonnes. Vous ajoutez une deuxième paire de crochets :

public class Main {
    public static void main(String[] args) {
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6}
        };

        System.out.println(grid[0][2]);
        System.out.println(grid[1][0]);

        for (int[] row : grid) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

grid[ligne][colonne] sélectionne une seule cellule. Comme chaque ligne est son propre tableau, grid.length est le nombre de lignes et grid[0].length est le nombre de colonnes de la première ligne. Les lignes n'ont même pas à être de la même longueur (c'est ce qu'on appelle un tableau irrégulier, ou jagged), bien que la plupart des grilles soient rectangulaires.

La classe utilitaire Arrays

Les tableaux en eux-mêmes n'ont presque aucune méthode - vous ne pouvez ni en trier ni en afficher un directement de manière utile. Java fournit une classe utilitaire java.util.Arrays remplie d'aides statiques précisément pour cela :

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        int[] copy = Arrays.copyOf(nums, 7);
        System.out.println(Arrays.toString(copy));

        int found = Arrays.binarySearch(nums, 8);
        System.out.println("Index of 8: " + found);
    }
}

Quelques points sur lesquels s'appuyer ici. Arrays.toString(arr) est la bonne façon d'afficher un tableau - en afficher un directement vous donne une chaîne inutile comme [I@1b6d3586. Arrays.sort trie sur place. Arrays.copyOf est la manière de « redimensionner » : il renvoie un nouveau tableau de la longueur demandée, en complétant avec les valeurs par défaut (les deux cases supplémentaires ci-dessus valent 0). Et Arrays.binarySearch ne fonctionne correctement que sur un tableau déjà trié.

Tableaux et ArrayList

Utilisez un simple tableau quand la taille est connue d'avance et ne changera pas - un ensemble fixe de jours de la semaine, un plateau de jeu, des données de pixels. Les tableaux sont rapides et légers, mais leur longueur fixe est une vraie limite : vous ne pouvez pas ajouter un septième élément à un tableau de longueur 6 sans en construire un tout nouveau.

Dès que vous avez besoin d'ajouter et de retirer des éléments librement, un tableau devient peu pratique. C'est à cela que sert ArrayList - une liste redimensionnable et extensible qui gère la recopie à votre place.

Suite : ArrayList

Quand vous ne savez pas combien d'éléments vous aurez, ou que ce nombre change à mesure que votre programme s'exécute, un tableau de longueur fixe vous gêne. ArrayList est la réponse de Java : une liste qui s'agrandit et se réduit à la demande, avec des méthodes add et remove au lieu de jongler avec les indices. C'est la suite.