Apprendre à programmer avec Processing

Les tableaux vont nous permettre de stocker plusieurs valeurs (chaîne, nombre) dans une structure unique. Pour déclarer un tableau, la syntaxe est un peu particulière :


int[] tab = new int[3];

Cette ligne comporte beaucoup d'informations :

int[] => indique que nous créons un tableau qui contiendra des entiers
tab => le nom du tableau
new int[3] => indique que ce tableau contiendra 3 éléments

Nous avons déclaré le tableau, mais pour l'instant, il est vide. Nous allons maintenant le remplir :


int[] tab = new int[3];
tab[0]=5;
tab[1]=65;
tab[2]=42;

Nous avons : tab[indice de position] = valeur

L'indice de position commence toujours à zéro.

Le tableau tab est donc composé des nombres 5,65 et 42

Il aurait aussi été possible de déclarer le tableau et de remplir le tableau en une seule ligne :


int[] tab = { 5, 65, 42 };

Pour "récupérer" les valeurs contenues dans le tableau, il suffit d'écrire nomDuTableau[indice de position], par exemple tab[0] est égal à 5.

À faire vous-même 9.1

Soit le programme suivant :


int[] tab = new int[3];
tab[0]=5;
tab[1]=65;
tab[2]=42;
println("Le premier élément du tableau tab est "+tab[0]);
println("Le deuxième élément du tableau tab est "+tab[1]);

Quel est le résultat attendu après l’exécution de ce programme ? Vérifiez votre réponse à l'aide de Processing.

À faire vous-même 9.2

Saisissez, analysez et testez ce programme :


String[] tabJour = {"lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"};
int jour;
for (int i=0;i<7;i=i+1){
 jour=i+1;
 println("Le jour "+jour+" est "+tabJour[i]);
}

Il est possible de connaitre le nombre d'éléments présents dans un tableau : tab.length est égal au nombre d'éléments présents dans le tableau tab

À faire vous-même 9.3

Saisissez, analysez et testez ce programme :


String[] tabJour = {"lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"};
int nbr;
nbr=tabJour.length;
println("Le tableau tabJour comporte "+nbr+" éléments");

Java (et donc Processing) propose une méthode alternative pour créer et manipuler des tableaux : les "ArrayList".

Les "ArrayList" ont de multiples avantages par rapport au tableau classique. Par exemple, la taille du tableau est dynamique, elle peut donc être modifiée facilement en ajoutant et en supprimant un ou des éléments. Un "ArrayList" peut contenir différents types de valeur (int, String...). La méthode ((la notion de méthode est expliquée dans la série d'activités consacrée à la programmation orientée objet ici) "add" permet d'ajouter un élément au tableau, la méthode "get" permet de récupérer une valeur dans le tableau.

À faire vous-même 9.4

Saisissez, analysez et testez ce programme :


ArrayList monTab = new ArrayList();
monTab.add(15);
monTab.add("hello");
println("le premier élément du tableau est :"+monTab.get(0));
println("le deuxième élément du tableau est :"+monTab.get(1));
monTab.add(2.5);
println("le troisième élément du tableau est :"+monTab.get(2));

Comme vous pouvez le constater, le système d'index est le même que pour les tableaux "classiques".

La méthode "size" vous permet de connaitre le nombre d'éléments présent dans un "ArrayList". Il est, comme dans le cas des tableaux "classiques", souvent judicieux d'utiliser une boucle for pour parcourir le tableau.

À faire vous-même 9.5

Saisissez, analysez et testez ce programme :


ArrayList monTab = new ArrayList();
monTab.add(15);
monTab.add("hello");
monTab.add(2.5);
for (int i=0; i<monTab.size(); i=i+1){
    println("index n°"+i+" : "+monTab.get(i));
}

La méthode "remove" permet de supprimer un élément du tableau

À faire vous-même 9.6

Saisissez, analysez et testez ce programme :


ArrayList monTab = new ArrayList();
monTab.add(15);
monTab.add("hello");
monTab.add(2.5);
for (int i=0; i<monTab.size(); i=i+1){
    println("index n°"+i+" : "+monTab.get(i));
}
monTab.remove(1);
println("l'élément d'index 1 vient d'être supprimé");
for (int i=0; i<monTab.size(); i=i+1){
    println("index n°"+i+" : "+monTab.get(i));
}

Il n'est pas recommandé de remplir un "ArrayList" avec des valeurs de différents types. Il est possible d'imposer le type des valeurs en utilisant la notation <type>.


ArrayList<Integer> monTab = new ArrayList<Integer>();
monTab.add(15);
monTab.add(20);
monTab.add(25);
for (int i=0; i<monTab.size(); i=i+1){
    println("index n°"+i+" : "+monTab.get(i));
}

Dans le cas où tous les éléments d'un "ArrayList" ont le même type, il est possible d'utiliser une boucle "for" un peu particulière pour parcourir le tableau.


ArrayList<String> monTab = new ArrayList<String>();
monTab.add("Hello");
monTab.add("World");
monTab.add("Toto");
for (String val : monTab){
    println(val+" : est un élément du tableau");
}

N.B. Il est tout à fait possible d'écrire :


ArrayList<String> monTab;
monTab = new ArrayList<String>();
monTab.add("Hello");
monTab.add("World");
monTab.add("Toto");
for (String val : monTab){
    println(val+" : est un élément du tableau");
}

Autre structure de données très importante : les dictionnaires.

Un dictionnaire est composé de paires "clé/valeur", une "clé" est une chaîne de caractères et une "valeur" est un nombre qui est associé à la "clé".

Dans Processsing, un dictionnaire est de type "IntDict" si les "valeurs" sont des entiers et de type "FloatDict" si les "valeurs" sont de type "float". Dans ce qui suit, nous étudierons exclusivement les dictionnaires de type "IntDict" mais tout ce qui sera dit sera aussi valable pour les dictionnaires de type "FloatInt".

Pour créer un nouveau dictionnaire, il faut écrire :


IntDict monDico;
monDico = new IntDict();

La méthode "set" permet de créer une nouvelle paire "clé/valeur". Cette méthode prend 2 paramètres :

premier paramètre : la clé
second paramètre : la valeur


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);

N.B. Nous allons utiliser un dictionnaire afin de créer un programme qui permettra de gérer des stocks de fruits.

À faire vous-même 9.7

Saisissez, analysez et testez ce programme :


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
println(monDico);

Comme vous pouvez le constater, un simple "println" permet d'afficher le contenu d'un dictionnaire :


IntDict size=2 { "pommes": 10, "oranges": 15 }

La méthode "set" permet aussi de modifier la valeur d'une paire "clé/valeur" existante :

À faire vous-même 9.8

Saisissez, analysez et testez ce programme :


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
println(monDico);
monDico.set("pommes",9);
println(monDico);

La méthode "get" renvoie la "valeur" associée à une "clé". Cette méthode prend un paramètre : la "clé" dont on recherche la valeur.

À faire vous-même 9.9

Saisissez, analysez et testez ce programme :


IntDict monDico;
int valOrange;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
valOrange=monDico.get("oranges");
println("Nous avons "+valOrange+" oranges en stock");

Un dictionnaire se comporte comme un tableau classique : la première paire a pour indice 0, la deuxième paire a pour indice 1,...

La méthode "key" renvoie la clé de la paire "clé/valeur" située à l'indice i, cette méthode prend un paramètre : l'indice i

À faire vous-même 9.10

Saisissez, analysez et testez ce programme :


IntDict monDico;
int valOrange;
String keyOrange;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
keyOrange=monDico.key(1);
valOrange=monDico.get(keyOrange);
println("Nous avons "+valOrange+" "+keyOrange+" en stock");

Cette méthode "key" a un interêt certain dans le cas de l'utilisation d'une boucle :

À faire vous-même 9.11

Saisissez, analysez et testez ce programme :


IntDict monDico;
int val;
String key;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
monDico.set("bananes",8);
for (int i=0;i<monDico.size();i=i+1){
    key=monDico.key(i);
    val=monDico.get(key);
    println("Nous avons "+val+" "+key+" en stock");
}

N.B. La méthode "size" le nombre de paire "clé/valeur" présent dans le dictionnaire.

La méthode "increment" permet d'augmenter d'une unité la "valeur" associé à une "clé". Cette méthode prend un paramètre : la "clé" dont il faut augmenter la "valeur".

À faire vous-même 9.12

Saisissez, analysez et testez ce programme :


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
monDico.set("bananes",8);
println(monDico);
monDico.increment("oranges");
println(monDico);

Si la "clé" passée en paramètre de la méthode "increment" n'existe pas, une nouvelle paire "clé/valeur" est alors créée (avec la "valeur" égale à un).

À faire vous-même 9.13

Saisissez, analysez et testez ce programme :


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
monDico.set("bananes",8);
println(monDico);
monDico.increment("fraises");
println(monDico);

Il est possible de classer les paires "clé/valeur" d'un dictionnaire :

avec la méthode "sortKeys" si vous voulez un classement par ordre alphabétique des "clés".
avec la méthode "sortValues" si vous voulez un classement selon les "valeurs" (ordre croissant).
avec la méthode "sortKeysReverse" si vous voulez un classement par ordre "alphabétique inverse" des "clés".
avec la méthode "sortValuesReverse" si vous voulez un classement selon les "valeurs" (ordre décroissant).

À faire vous-même 9.14

Saisissez, analysez et testez ce programme :


IntDict monDico;
monDico = new IntDict();
monDico.set("pommes",10);
monDico.set("oranges",15);
monDico.set("bananes",8);
println("non classé : "+monDico);
monDico.sortKeys();
println("alphabétique clé : "+monDico);
monDico.sortKeysReverse();
println("alphabétique-inverse clé : "+monDico);
monDico.sortValues();
println("croissant valeur : "+monDico);
monDico.sortValuesReverse();
println("décroissant valeur : "+monDico);

Il existe beaucoup d'autres méthodes très intéressantes permettant de manipuler les dictionnaires, je vous invite à les découvrir en consultant la documentation officielle de Processing.