Longueur d'un tableau Java : champ .length

Un tableau Java stocke sa taille de façon permanente, et vous lisez cette taille via le champ length. C'est l'une des opérations les plus courantes sur les tableaux — pour les parcourir en boucle, trouver le dernier élément, ou vérifier s'ils contiennent des données. Ce chapitre montre comment fonctionne length, en quoi il diffère de String.length(), et comment mesurer les tableaux multidimensionnels.

Utiliser le champ `length`

Chaque tableau en Java expose un champ public final int length qui contient le nombre d'éléments. Vous le lisez sans parenthèses, car c'est un champ, pas une méthode.

int[] scores = {88, 92, 75, 60, 100};
int size = scores.length;          // 5
System.out.println(scores.length); // 5

La valeur est fixée lors de la création du tableau et ne change jamais — les tableaux en Java ne grandissent ni ne rétrécissent. Si vous avez besoin d'une collection redimensionnable, utilisez plutôt ArrayList, qui expose size() en tant que méthode. Le champ length fonctionne également de la même manière pour les tableaux de tout type : String[], double[], ou même un tableau d'objets.

Champ vs méthode : `length` vs `length()`

Une source fréquente de confusion est de mélanger les tableaux et les chaînes. Un tableau utilise le champ length ; une String utilise la méthode length(). Écrire le mauvais ne compilera pas.

int[] numbers = {1, 2, 3};
String text = "hello";

System.out.println(numbers.length);   // field, no ()  -> 3
System.out.println(text.length());    // method, with () -> 5

Type	Comment obtenir la taille	Parenthèses ?
Tableau (`int[]`, `String[]`, ...)	`array.length`	Non
`String`	`str.length()`	Oui
`ArrayList`, `HashMap`, ...	`collection.size()`	Oui

Une règle simple : les tableaux sont les seuls des trois à utiliser un champ nu. Tout le reste utilise un appel de méthode.

Gérer les cas de tableau vide et de dernier élément

Un tableau créé avec la taille 0 est un objet réel et non null dont la length est 0. C'est différent d'une référence null, qui n'a pas de longueur du tout — lire .length sur null lève une NullPointerException. Pour utiliser la taille en toute sécurité, itérez de 0 jusqu'à length - 1, car le dernier index valide est toujours inférieur de un à la longueur.

int[] empty = new int[0];
System.out.println(empty.length);          // 0, not an error

int[] data = {10, 20, 30};
int last = data[data.length - 1];          // 30
for (int i = 0; i < data.length; i++) {
    System.out.println(data[i]);
}

Si un tableau peut être null, protégez-vous d'abord : if (data != null && data.length > 0).

Mesurer les tableaux multidimensionnels

Un tableau à deux dimensions en Java est en réalité un tableau de tableaux. La length extérieure donne le nombre de lignes, et chaque ligne possède sa propre length pour le nombre de colonnes de cette ligne. Les lignes peuvent même avoir des longueurs différentes (un tableau irrégulier), donc lisez toujours la longueur de chaque ligne individuellement plutôt que de supposer une largeur uniforme.

int[][] grid = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};
System.out.println(grid.length);     // 3 rows
System.out.println(grid[0].length);  // 3 columns in row 0
System.out.println(grid[2].length);  // 4 columns in row 2

Pour compter chaque élément, additionnez la longueur de chaque ligne plutôt que de multiplier les lignes par les colonnes — ce raccourci ne fonctionne que pour les grilles parfaitement rectangulaires.

Exemple complet

Le programme ci-dessous rassemble toutes ces idées : un tableau plat, la distinction champ-vs-méthode, un tableau vide, l'accès au dernier élément, et un tableau 2D irrégulier dont la taille totale est calculée en additionnant les longueurs de lignes.

java— editable, runs on the server

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // A one-dimensional array: length is a final field, not a method.
        int[] scores = {88, 92, 75, 60, 100};
        System.out.println("scores.length = " + scores.length);

// Strings use length() (a method); arrays use length (a field).
        String word = "hello";
        System.out.println("word.length() = " + word.length());

// An empty array has length 0; it is NOT null.
        int[] empty = new int[0];
        System.out.println("empty.length = " + empty.length);

// Iterating safely: the last valid index is length - 1.
        int last = scores[scores.length - 1];
        System.out.println("last element = " + last);

// A 2D array is an array of arrays: outer length vs. each row length.
        int[][] grid = {
            {1, 2, 3},
            {4, 5},
            {6, 7, 8, 9}
        };
        System.out.println("grid.length (rows) = " + grid.length);
        System.out.println("grid[2].length (cols in row 2) = " + grid[2].length);

// Total elements in a jagged 2D array: sum each row's length.
        int total = 0;
        for (int[] row : grid) {
            total += row.length;
        }
        System.out.println("total elements in grid = " + total);

System.out.println("grid contents = " + Arrays.deepToString(grid));
    }
}

Ce que l'on retient de l'exécution :

scores.length = 5 confirme que length se lit comme un champ nu sans parenthèses et retourne le nombre d'éléments.
word.length() = 5 montre que la taille d'une String provient de la méthode length(), un mécanisme différent du champ de tableau.
empty.length = 0 prouve qu'un tableau de longueur zéro est un objet valide, pas null, et que lire sa longueur est sans danger.
last element = 100 démontre que l'index final est length - 1, car l'indexation commence à 0.
grid.length (rows) = 3 tandis que grid[2].length vaut 4, montrant que la longueur extérieure compte les lignes et que chaque ligne porte sa propre longueur — additionnée pour obtenir total elements in grid = 9.

Exercice

Pratique

En Java, comment obtenir correctement le nombre d'éléments dans un tableau int nommé 'data' ?

data.lengthdata.length()data.size()length(data)

Utiliser le champ length

Champ vs méthode : length vs length()