Opérations de base avec les tableaux unidimensionnels

1. Tableau de type String

Et brièvement, je voudrais parler d’un tableau de type String.

Comme nous l’avons déjà dit, un tableau peut être de n’importe quel type. Cela signifie qu’on peut créer un tableau de type String. Voici à quoi ressemblerait le code si nous devions écrire un programme qui « lit au clavier 10 lignes et les affiche à l’écran dans l’ordre inverse ».

String[] array = new String[10];	// Créer un tableau-objet de 10 éléments
for (int i = 0; i < 10; i++)		// Boucle de 0 à 9
{
   array[i] = console.nextLine();	// Lire une ligne au clavier et la stocker dans la case du tableau
}
for (int i = 9; i >= 0; i--)		// Boucle de 9 à 0
{
    System.out.println(array[i]);	// Afficher la case suivante du tableau
}

Le code a pratiquement peu changé ! Il a seulement fallu remplacer le type int par String lors de la création du tableau. Pour le reste, c’est exactement la même chose !

Découverte de null

Voici une devinette — que contiennent les cases de chacun de ces tableaux juste après leur création ?

int[] numbers = new int[10];
String[] strings = new String[10];
User[] users = new User[10];

En réfléchissant, il est probable que les cases de numbers contiennent 0. Correct.

Alors, par la même logique, les cases de strings devraient être remplies par des chaînes vides — "". Admettons.

Et celles du tableau users ? Des User vides ?

C’est là le piège : il n’existe pas une « valeur par défaut » pour chaque type de données. Les créateurs de Java ont donc inventé une constante spéciale — null. null — c’est une référence vide. Lorsqu’une variable d’un type-objet est créée, sa valeur initiale est null : une référence vers rien, l’absence de référence.

String name; 	// name contient null
name = "Alex";  // name contient une référence vers l'objet/chaîne "Alex"
name = null; 	// name contient null

Travailler avec null

Impossible d’appeler des méthodes sur un objet si sa référence vaut null — l’objet n’existe pas ! Avec ce code, le programme se terminera par une erreur :

String name; 	// name contient null
String upperName = name.toUpperCase(); // Provoquera une NullPointerException: name == null

Pour ce qui est de notre « devinette », la réponse sera la suivante :

int[] numbers = new int[10];		// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
String[] strings = new String[10];  // {null, null, null, null, null, null, null, null, null, null}
User[] users = new User[10];		// {null, null, null, null, null, null, null, null, null, null}

Seuls les types primitifs ont une « valeur par défaut ». Tous les autres types ont par défaut la valeur null. La valeur initiale d’une String n’est pas la chaîne vide. C’est la vie.

2. Tableau de type String en mémoire

Image 1. Comment un objet String est disposé en mémoire :

Notez que le texte de la chaîne n’est pas stocké directement dans la variable : un bloc mémoire séparé lui est alloué. Et la variable de type String contient l’adresse (référence) de l’objet avec le texte.

Image 2. Comment un tableau d’entiers est disposé en mémoire :

Vous avez déjà vu cette image.

Image 3. Comment un tableau de chaînes est disposé en mémoire :

À gauche, nous voyons la variable-tableau de type String[] (elle stocke l’adresse de l’objet-tableau).

Au milieu — l’objet-tableau de type String.

Et à droite — les objets-chaînes, qui contiennent des textes.

Dans les cases de l’objet-tableau de type String, ce ne sont pas les chaînes elles-mêmes (les textes) qui sont stockées, mais leurs adresses (références). Exactement comme les variables de type String stockent des adresses de chaînes (de texte).

3. Initialisation rapide d’un tableau en Java

Les tableaux sont très utiles, c’est pourquoi les développeurs Java ont essayé de rendre leur utilisation aussi pratique que possible. Et la première chose qu’ils ont faite — c’est simplifier l’initialisation d’un tableau, c’est-à-dire l’insertion de valeurs initiales.

Très souvent, en plus des données que le programme lit quelque part, il a besoin de ses propres données internes. Par exemple, nous devons stocker dans un tableau la longueur de tous les mois. À quoi ce code pourrait-il ressembler :

int[] months = new int[12];
months[0] = 31; // janvier
months[1] = 28; // février
months[2] = 31; // mars
months[3] = 30; // avril
months[4] = 31; // mai
months[5] = 30; // juin
months[6] = 31; // juillet
months[7] = 31; // août
months[8] = 30; // septembre
months[9] = 31; // octobre
months[10] = 30; // novembre
months[11] = 31; // décembre

Mais il existe un moyen de l’écrire plus court — merci aux créateurs de Java :

// longueurs des mois de l'année
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

On peut simplement énumérer, séparées par des virgules, toutes les valeurs du tableau !

Le compilateur peut déterminer le type du conteneur (objet-tableau) à partir du type de la variable-tableau. Et pour déterminer la longueur du tableau — il suffit de compter le nombre d’éléments écrits entre les accolades.

C’est pourquoi ce code peut être écrit encore plus court :

// longueurs des mois de l'année
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

N’est-ce pas élégant ? 🙂 Cette écriture s’appelle « initialisation rapide d’un tableau ». Elle fonctionne, d’ailleurs, non seulement pour le type int...

// noms des mois de l'année
String[] months = { "Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre" };

4. Boucle for-each

Parcourir tous les éléments d’un tableau est une opération si fréquente qu’on a inventé une boucle spéciale pour cela — for-each. Elle s’écrit ainsi :

for (int score : scores)
{
    System.out.println("Points: " + score);
}

Ici, la boucle itère elle-même les éléments — aucun index manuel. Mais on ne peut pas modifier les éléments directement (la variable de la boucle ne contient qu’une copie de la valeur). En revanche, c’est très pratique pour simplement « parcourir » le tableau.

Le compilateur transformera le code de la boucle for-each en le code ci-dessous :

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

Aucune magie. Et cela permet de comprendre pourquoi vous ne pouvez pas modifier les éléments du tableau via la variable score.

Écrivons encore un exemple : calculons la somme de tous les points.

int sum = 0;
for (int score : scores)
{
    sum += score;
}
System.out.println("Somme de tous les points: " + sum);

Quand utiliser quelle boucle ?

• Si vous avez besoin d’un index ou qu’il faut modifier les éléments — utilisez la boucle for.
• Si vous voulez simplement parcourir les valeurs — for-each est plus rapide et plus propre.

5. Modification des éléments d’un tableau

Et si nous devons augmenter chaque note de 1 point (par exemple, pour bonne conduite) ? Ici, il faut une for classique avec un index, car c’est la seule manière de modifier les valeurs du tableau.

Exemple : augmenter chaque élément de 1

for (int i = 0; i < grades.length; i++) {
    grades[i] = grades[i] + 1;
}

Après l’exécution de ce code, le tableau grades contiendra de nouvelles valeurs.

Pourquoi ne pas le faire avec for-each ?

for (int grade : grades) {
    grade = grade + 1; // Ne fonctionne pas !
}

Ce code ne modifie pas le tableau, car grade est une copie de la valeur du tableau, et non une référence vers l’élément lui-même.

6. Calculs basés sur un tableau

Les tableaux sont souvent utilisés pour des calculs : somme, moyenne, maximum, minimum, etc.

Exemple : somme de tous les éléments du tableau

int sum = 0;
for (int i = 0; i < grades.length; i++) {
    sum += grades[i]; // équivaut à sum = sum + grades[i];
}
System.out.println("Somme des notes: " + sum);

Exemple : recherche de la valeur maximale

int max = grades[0]; // commençons par le premier élément
for (int i = 1; i < grades.length; i++) {
    if (grades[i] > max) {
        max = grades[i];
    }
}
System.out.println("Note maximale: " + max);

Exemple : recherche de la valeur minimale

int min = grades[0]; // commençons par le premier élément
for (int i = 1; i < grades.length; i++) {
    if (grades[i] < min) {
        min = grades[i];
    }
}
System.out.println("Note minimale: " + min);

Exemple : calcul de la moyenne arithmétique

int sum = 0;
for (int i = 0; i < grades.length; i++) {
    sum += grades[i];
}
double average = (double) sum / grades.length; // il faut absolument convertir en double !
System.out.println("Note moyenne: " + average);

Attention : pour obtenir un nombre décimal et non un entier, il faut convertir explicitement la somme en type double avant la division.

7. Exercices pratiques

Saisie d’un tableau au clavier

Il est souvent nécessaire de remplir un tableau avec des valeurs saisies par l’utilisateur. Pour cela, on utilise la classe Scanner et une boucle.

Scanner console = new Scanner(System.in);

int n = 5; // taille du tableau
int[] numbers = new int[n];

System.out.println("Saisissez " + n + " nombres:");
for (int i = 0; i < n; i++) {
    numbers[i] = console.nextInt();
}

System.out.println("Vous avez saisi:");
for (int i = 0; i < n; i++) {
    System.out.println(numbers[i]);
}

Affichage du tableau dans l’ordre inverse

Parfois, il faut afficher les éléments du tableau depuis la fin (par exemple, pour savoir qui est entré en dernier dans la pièce).

for (int i = grades.length - 1; i >= 0; i--) {
    System.out.println("Note n°" + (i + 1) + ": " + grades[i]);
}

8. Erreurs typiques lors du travail avec des tableaux unidimensionnels

Erreur n°1 : dépassement des limites du tableau

Le problème le plus courant — tenter d’accéder à un élément inexistant. En Java, cela entraîne l’exception ArrayIndexOutOfBoundsException. Rappelez-vous : le dernier index autorisé est arr.length - 1.

int[] arr = new int[5];
System.out.println(arr[5]); // Erreur ! Les index vont de 0 à 4.

Erreur n°2 : oubli d’initialiser le tableau

Vous avez déclaré une variable, mais n’avez pas créé le tableau :

int[] arr;
arr[0] = 5; // Erreur ! Le tableau n'est pas créé.

Il faut créer le tableau avec new :

arr = new int[10];

Erreur n°3 : tentative de modifier les éléments du tableau via for-each

Dans une boucle for-each, la variable est une copie de la valeur, et non une référence vers l’élément :

for (int x : arr) {
    x = 100; // Ne modifie pas le tableau !
}

Pour modifier les valeurs, utilisez une for classique avec index.

Erreur n°4 : mauvaise utilisation de la longueur du tableau

Parfois, on confond la longueur du tableau avec le dernier index :

for (int i = 0; i <= arr.length; i++) { // Erreur ! Il faut i < arr.length
    // ...
}

Ce code entraînera un dépassement des limites.

Erreur n°5 : conversion implicite de types

Si le tableau est de type int, on ne peut pas lui affecter directement une valeur de type double :

int[] arr = new int[3];
arr[0] = 3.14; // Erreur ! 3.14 est un double.