Java 04 : Tableaux et itération

Un tableau (ou array) est une variable spéciale qui peut contenir plusieurs valeurs à la fois. Tu peux retrouver ce type de variable dans tous les langages de programmation.

Au fur et à mesure que tu avances dans la quête, n'hésite pas à tester le code qui t'est proposé, et à le manipuler, c'est le meilleur moyen d'apprendre.

Dans un second temps, tu vas découvrir les différentes façons de faire des boucles en Java. Les boucles sont des structures de contrôle très utilisées, car elles vont te permettre de faire le même traitement plusieurs fois... En boucle !

Objectifs

• Découvrir les variables de type "array"
• Apprendre à les manipuler
• Découvrir des fonctions de traitements
• Comprendre l'utilité de faire des boucles
• Maîtriser les structures de contrôle for, while

Déclarer un tableau

Imagine, par exemple, que tu souhaites stocker la liste des armes d'Indy. Ton code risque de ressembler à :

String weapon1 = "whip";
String weapon2 = "gun";
String weapon2 = "saber";

Pour rappel, notre objectif est de tout stocker au sein d'une seule et même variable. Deux possibilités s'offrent à nous :

• Utiliser la structure de langage array()

String[] weapons = new String[] {"whip", "gun", "saber"};

• Syntaxe courte

String[] weapons = {"whip", "gun", "saber"};

Tu remarqueras ici que le nom de la variable a été mis au pluriel. Cela est volontaire, étant donné que cette dernière va contenir plusieurs valeurs. On garde ainsi une cohérence entre le nom de la variable et son contenu.

Voilà les deux façons de déclarer un tableau. Quelle que soit la solution utilisée, le processus reste le même : tu insères tes valeurs et chacune d'entre elles est séparée par une virgule.

Quel que soit ton choix, la bonne pratique est surtout de rester cohérent. Si tu choisis une syntaxe, conserve-la dans tout ton code. Sache tout de même que la syntaxe courte est de plus en plus utilisée, et également plus claire. Privilégie-la.

Attention, nous avons déclaré ici ce que l'on appelle un tableau à index numérique. Nous verrons pourquoi juste après. Attention également aux guillemets ! Ces dernières sont présentes, car les valeurs sont de type "string". Mais sache qu'un tableau peut contenir d'autres types d'éléments, par exemple:

int[] evens = {0, 2, 4, 6, 8};

Ici, la variable evens est un tableau qui contient des éléments de type int. Sache que tu pourrais par exemple aussi créer des tableaux de boolean, double, array (eh oui un tableau peut contenir un autre tableau) et Object (tu verras les objets un peu plus tard, dans une prochaine quête).

Tu n'es pas obligé d'initialiser des valeurs à la création de ton tableau, mais dans ce cas-là, tu devras donner la taille maximale de ce dernier :

double[] values = new double[10]; 

Le tableau précédent aura donc 10 cases "vides"... mais pas tout à fait vides en fait. Elles auront une valeur par défaut : 0.0 ! Tu peux retrouver ci-dessous les valeurs par défaut en fonction des types :

• boolean : false

• int : 0

• double : 0.0

• String : null

• Object : null

Index

Bon, tu as vu comment stocker plusieurs informations au sein d'une seule et même variable. C'est génial, mais comment faire pour récupérer une valeur précise ? Heureusement, les index sont là. Dans cette étape, tu vas voir les index numériques. Lors de la déclaration d'un tableau, si tu ne précises pas les index, ces derniers seront par défaut numériques. Un tableau indexé numériquement est tout simplement une liste d'éléments repérés chacun par un index numérique unique. Ainsi, le premier élément du tableau correspondra à l'index 0, le second à l'index 1, le troisième à l'index 2, etc. Tu noteras bien que la numérotation commence à 0 et non à 1 !

Pour accéder à un élément du tableau, il suffit d'y faire référence de cette manière : tableau[0], tableau[1], tableau[2]... Reprenons notre exemple précédent, notre tableau d'armes :

String[] weapons = {"whip", "gun", "saber"};

Dans ce tableau, whip est situé à l'index 0 de notre tableau $weapons, gun à l'index 1, et saber à l'index 2 (pour rappel, le premier élément du tableau est référencé à l'index 0). Et maintenant, si tu souhaites afficher les différentes valeurs du tableau :

System.out.println(weapons[0]); // affiche : whip
System.out.println(weapons[1]); // affiche : gun
System.out.println(weapons[2]); // affiche : saber

Attention, dans l'exemple précédent, le code System.out.println(weapons[3]); renverrait une erreur. En effet, tu ne peux accéder à l'index d'un tableau qui n'existe pas.

• Modifier des éléments d'un tableau Malheureusement en Java, tu ne peux pas ajouter de nouveaux éléments à un tableau, une fois qu'il a été initialisé. Cependant, tu peux remplacer les valeurs existantes (et celles par défaut) :

String[] weapons = {"whip", "gun", "saber"};
weapons[2] = "sword";
System.out.println(Arrays.toString(weapons)); // affiche [whip, gun, sword]

Arrays.toString(weapons) est une méthode qui te permet de transformer un tableau en chaîne de caractères. Pratique pour voir le contenu d'un tableau ! Il te faudra cependant faire un import java.util.Arrays; au début de ton code.

Tableau multidimensionnel

Dans l'exemple précédent, tu as eu à gérer un tableau avec les armes d'une seule personne, ton ami Indiana. Mais comment faire si tu souhaites avoir au sein d'une même variable, les armes d'Indiana et de ses ennemis ?

Pour cela, il faut faire ce que l’on appelle un tableau multidimensionnel. Il s'agit finalement d'un tableau qui va contenir en valeur d'autres tableaux, etc...

String[] weaponsIndiana = {"whip", "gun", "saber"};
String[] weaponsHelen = {"knife", "shield"};
String[] weaponsRavenwood = {"belt", "dagger", "gun", "shield"};

On peut mieux faire, tu ne crois pas ? Grâce aux tableaux multidimensionnels, tu vas pouvoir tout regrouper au sein d'une seule et même variable, afin d'avoir tous les éléments disponibles simplement et rapidement. Commence par déclarer ton tableau :

String[][] weapons;

weapons est une variable de type tableau de tableau de chaînes, qui, pour le moment, est vide. Tu vas maintenant ajouter les armes de chacun de nos personnages:

weapons = new String[][] {
    weaponsIndiana,
    weaponsHelen,
    weaponsRavenwood
};

Ainsi, tu pourras afficher l'ensemble des armes des personnages de la façon suivante :

System.out.println(Arrays.toString(weapons[0])); // [whip, gun, saber]
System.out.println(Arrays.toString(weapons[1])); // [knife, shield]
System.out.println(Arrays.toString(weapons[2])); // [belt, dagger, gun, shield]

Le premier index sert donc à afficher le tableau des armes d'un personnage. Pour afficher les différentes armes, il te faudra spécifier un autre index, correspondant à la position de l'arme dans le tableau. Tu feras donc :

System.out.println(weapons[0][0]); // affiche whip;
System.out.println(weapons[0][2]); // affiche saber;
System.out.println(weapons[1][1]); // affiche shield;
System.out.println(weapons[2][2]); // affiche gun;

C'est ce que l’on appelle un tableau multidimensionnel, un tableau qui contient d'autres tableaux en valeur. Il n'y a de limite que la compréhension du tableau, mais tu peux imaginer des tableaux à 3, 4, 5 dimensions.

Longueur

En Java, un tableau possède une propriété très utile : sa longueur.

Tu peux l'appeler de la façon suivante : tableau.length.

Comme tu le remarques, il n'y a pas de parenthèse : en effet, length est une propriété du tableau et non une méthode. Pas d'inquiétude, tu apprendras la différence entre les deux plus tard, avec la programmation orientée objets.

String[] weapons = {"whip", "gun", "saber"};
System.out.println(weapons.length); // affiche 3

Attention, pour un tableau multidimensionnel

String[][] weapons = new String[][] {
    {"whip", "gun", "saber"},
    {"knife", "shield"},
    {"belt", "dagger", "gun", "shield"}
};
System.out.println(weapons.length); // affiche 3
System.out.println(weapons[1].length); // affiche 2

En effet, le tableau weapons contient 3 éléments, et le sous-tableau $weapons[1] contient lui, 2 éléments. Ainsi, sur la même logique :

System.out.println(weapons[2].length); // affiche 4

N'hésite pas à manipuler ces exemples afin de bien comprendre comment cela fonctionne.

Trier

Java te permet d'employer une bibliothèque contenant quelques méthodes à utiliser sur les tableaux. Tu as précédemment vu la méthode toString() qui te permet d'afficher le contenu d'un tableau sous forme de chaîne.

Pour utiliser cette bibliothèque Arrays, il te faut ajouter import java.util.Arrays; au début de ton code.

• Trier un tableau par ordre croissant de valeurs avec sort()

int[] array = {2, 4, 1, 0, 8, 5};
Arrays.sort(array);
System.out.println(Arrays.toString(array)); // [0, 1, 2, 4, 5, 8]

Cela marche aussi si tu as un tableau ayant pour valeur des chaînes de caractères. Le tableau sera trié par ordre alphabétique

String[] weapons = {"whip", "gun", "saber"};
Arrays.sort(weapons);
System.out.println(Arrays.toString(weapons)); // [gun, saber, whip]

Attention : l'utilisation de sort modifie directement le tableau passé en paramètre.

Boucles - For

La boucle for est la plus simple à mettre en place. Tu vas indiquer à Java de boucler un certain nombre de fois. C'est toi qui définis ce nombre. La boucle for intègre un compteur.

Sa notation est la suivante :

for (expr1; expr2; expr3) {
    // Do something
    // Do something
    // Do something

Dans l'exemple ci-dessus, ce qui est très important, ce sont les expressions et leurs emplacements :

• expr1 : dans cette première expression, tu vas initialiser une variable qui va te servir de compteur (souvent int i, mais ce n'est pas obligatoire).

• expr2 : dans cette deuxième expression, tu vas définir la limite de ce compteur (sa valeur maxi ou mini en fonction de la 3e expression).

• expr3 : dans cette troisième expression, tu vas définir l'action sur ton compteur à chaque tour de boucle (souvent une incrémentation, mais ça n'est pas obligatoire).

// Exemple concret d'une boucle allant de 0 à 9 avec un pas de 1
for (int i = 0; i < 10; i++) {
    // Do something
}

// Mais j'aurais pu l'écrire comme cela
for (int compteur = 0; compteur < 10; compteur++) {
    // Do something
}

// Et si j'avais voulu aller de 9 à 0
for (int i = 9; i >= 0; i--) {
    // Do something
}

Dans le cas d'un tableau, il est utile d'ajouter comme limite la longueur du tableau.

Si l'indice commence à 0 et que la limite est égale à la longueur, il va falloir s'arrêter avant, sinon on va avoir un problème !

Tu vas pouvoir utiliser l'indice afin de récupérer successivement chaque valeur du tableau :

String[] weapons = {"whip", "gun", "saber"}; // la longueur est 3

for (int i = 0; i < weapons.length; i++) {
    System.out.println(weapons[i]); // affiche l'arme à la position i
}

// whip
// gun
// saber

Boucles - While

Attention : cette boucle peut être dangereuse si elle est mal utilisée. En effet, elle peut être infinie et planter ton programme.

// Exemple de boucle while
int i = 0;
while (i < 10) {
    i++
    // Do something
}

// Exemple de boucle infinie (A NE PAS FAIRE !!!)
String firstname = 'Henry';
while (firstname != 'Indy') {
    firstname = 'Indiana';
    // Do something...
}

Le premier exemple est simple, on boucle tant que $i est strictement inférieur à 10.

Le second est une boucle infinie. Étant donné que le while boucle tant que la condition est true, il faut bien veiller à ce que l'expression du while devienne false.

Boucles - For each

Le foreach permet de boucler sur les tableaux ou sur toute variable qui est itérable.

Voici comment la mettre en place :

for (type element : tableau) {
    // Do something...
}

Ce type de boucle est très pratique dès lors que tu n'as pas besoin d'index.

String[] weapons = {"whip", "gun", "saber"};

for (String weapon : weapons) {
    System.out.println(weapon); // affiche l'arme
}

On dit que le for each va itérer sur chaque élément du tableau (ou de la collection).

Cela signifie que chaque élément va être lu séquentiellement, à chaque tour de boucle.

Challenge

Créer la filmographie d'Indiana

1. Dans la méthode main d'une classe Movies.java, crée :

un premier tableau contenant 3 titres de films dans lesquels joue notre ami Indiana (Hint),un second tableau contenant, pour chaque film que tu as choisi, les 3 principaux acteurs (Hint : pense aux tableaux à plusieurs dimensions).

1. Une fois les tableaux créés, réalise une boucle pour afficher la liste des titres de films, ainsi que les acteurs associés de la manière suivante :Dans le film title, les principaux acteurs sont : actor1, actor2, actor3
2. La liste devra s'afficher à la compilation, puis exécution du code dans le terminal.
3. Pour soumettre tes solutions, uploade le fichier dans un gist, puis poste le lien de ce dernier.

Critères de validation

• Le fichier contient les tableaux, et on y retrouve bien 3 films, ainsi que 3 acteurs par film.
• Une boucle est utilisée pour afficher les films et leurs acteurs.
• Lorsque tu exécutes le script depuis ton terminal, le résultat affiché est bien : "Dans le film title, les principaux acteurs sont : actor1, actor2, actor3".