Le dernier blog

Processing, douzième cours

Après les variables, les tableaux, parfois appelés listes. Ce sujet n’est pas toujours le plus simple à comprendre ou en tout cas à faire comprendre (peut-être est-ce juste moi qui l’explique mal). Il faut dire que le tableau est un type de donnée dont l’usage est assez abstrait, rien à voir avec les commandes de dessin géométrique de Processing dont l’utilité est immédiate et évidente.
Un tableau est tout bêtement un ensemble de variables (qui doivent impérativement être du même type, dans le cas de Processing). Cet exemple le montre de manière simple :

String[] animaux = {"chat", "chien", "cheval", "lapin", "souris"};
print (animaux[2]);

Si vous lancez ce programme, vous verrez ceci :

Tout d’abord, une fenêtre d’affichage de la taille et de la couleur par défaut s’ouvre, mais elle ne contient rien, puisque nous ne l’utilisons pas.
Dans la zone noire, qui est la zone dite « de texte » et qui permet à Processing de nous adresser des messages sollicités (en gris) ou des messages d’erreur (en orange), on peut voir écrit le mot « cheval ». La commande print() sert en effet à afficher quelque chose dans la zone de texte — si j’écris print(« bonjour ») dans le programme, le mot bonjour s’affichera dans la zone de texte.
Ici nous avons demandé à Processing de nous donner le troisième élément (la numérotation commence à zéro) de la liste animaux, créée sur la ligne du dessus.
Revenons un peu en arrière.
En écrivant String[] animaux, je déclare un « tableau » de chaînes de caractère dont le nom est « animaux ». Ce sont les deux crochets qui suivent le type qui signifient qu’il s’agit d’un tableau et non d’une variable isolée. Tout en déclarant ce tableau, je lui ai attribué un contenu entre accolades, contenu qui est une suite de chaînes de caractères séparées par des virgules. Son premier élément est le mot « chat« , le second est le mot « chien« , et ainsi de suite.
Pour Processing (comme pour de nombreux langages), ma liste contient cinq éléments, numérotés 0, 1, 2, 3 et 4. Si je souhaite accéder au premier élément je demanderais animaux[0].
Si je souhaite remplacer le mot « lapin » par le mot « lièvre » j’écrirais animaux[3]= »lièvre ». Pour ajouter un sixième animal, par exemple l’éléphant, à ma liste, c’est un peu plus compliqué, je dois écrire ceci :

animaux = append (animaux, "éléphant");

(la commande append(tableau, valeur) signifie que l’on ajoute une valeur à la fin d’un tableau).
Pour ajouter une valeur à un emplacement précis du tableau on utilise la commande splice(liste, valeur, position). La ligne qui suit intercalera le mot « toucan » entre les mots « chien » et « cheval », c’est à dire à la place 2.

animaux = splice(animaux , "toucan", 2);

Pour enlever sa dernière valeur à un tableau, la commande est shorten(tableau), comme ceci :

animaux = shorten(animaux);

La syntaxe que j’ai utilisé plus haut pour déclarer mon tableau tout en lui donnant un contenu n’est pas typique. Généralement, on écrit plus laborieusement ceci :

int[] maListeDeChiffres = new int[12];

qui signifie que je déclare un tableau de 12 chiffres entiers, auxquels je pourrais donner des valeurs par la suite, par exemple comme ceci :

maListeDeChiffres[0] = 128;
maListeDeChiffres[1] = 256
maListeDeChiffres[2] = 64;

ou pourquoi pas à l’aide d’une boucle, de cette manière :

for(int a=0;a<12;a++){
  maListeDeChiffres[a]=a*10;
}

… Dans ce cas, ma liste contiendra les valeurs {0,10,20,30,40,50,60,70,80,90,100,110}

On peut, par ailleurs, créer des tableaux de tableaux, comme ceci :

int[][] monTableauAdeuxDimensions = new int[4][2];
monTableauAdeuxDimensions[0][0]= 10;
monTableauAdeuxDimensions[0][1]= 20;
monTableauAdeuxDimensions[1][0]= 15;
monTableauAdeuxDimensions[1][1]= 25;
monTableauAdeuxDimensions[2][0]= 143;
monTableauAdeuxDimensions[2][1]= 321;
monTableauAdeuxDimensions[3][0]= -10;
monTableauAdeuxDimensions[3][1]= 28;

Ici je dis que je crée un tableau de type entier nommé monTableauAdeuxDimensions qui contient quatre éléments dont chacun est un tableau de deux éléments. Si je demande à savoir quel est l’élément monTableauAdeuxDimensions[2][1], il me sera répondu 321. En revanche, contrairement à Java, C++, Php ou Javascript, Processing ne gère pas les tableaux dits « associatifs » (où chaque valeur du tableau est associée à une clé), sujet sur lequel je ne m’étendrais donc pas bien qu’il était important que je le signale.

Pour connaître le nombre d’éléments d’un tableau, on utilise la propriété length. Ainsi, dans l’exemple qui se trouve ci-dessus, monTableauAdeuxDimensions.length a la valeur de 4 (il y a quatre éléments dans monTableauAdeuxDimensions) et monTableauAdeuxDimensions[0].length a la valeur de 2 car il y a deux éléments dans le premier élémént (numéroté zéro) de monTableauAdeuxDimensions.
Un exemple pratique.:

int[] mesPositions = {1,3,6,11,17,24,32,41,51,62,73,84,95};
for(int i=0;i<mesPositions.length;i++){
  line (0, mesPositions[i],100,mesPositions[i]);
}

Avec ces quelques lignes, nous commençons par déclarer une liste de type entier (int[]), nommée mesPositions et contenant treize éléments numériques : 1, 3, 6, 11, 17, etc.
Nous exécutons ensuite une boucle qui utilise une variable nommée i dont la valeur va passer de 0 (zéro) à mesPositions.length, c’est à dire 13, puisque la liste mesPositions contient treize éléments.
À chaque passe de cette boucle, une ligne est tracée entre les points (0, mesPositions[i]) et (100, mesPositions[i]). Lors du premier passage, i sera égal à 0, donc mesPositions[i] aura la valeur de mesPositions[0] c’est à dire 1. Ma première ligne sera donc tracée entre (0, 1) et (100,1). Au second passage, mesPositions[i] aura la valeur 3, donc la ligne sera tracée entre (0,3) et (100,3). Et ainsi de suite. On peut le voir avec l’illustration qui se trouve à droite et qui est le produit ce programme : treize lignes sont tracées, chacune commence à gauche (abscisse : 0) et se termine à droite (abscisse : 100) et a pour ordonnée les chiffres contenus dans notre liste, à savoir 1, 3, 6, 11, 17, etc.

Très rapidement et à l’attention des programmeurs habitués à manipuler des listes, quelques commandes utiles (cliquer sur leur nom pour obtenir la page correspondante dans la documentation de processing) :

• arrayCopy() permet de copier un tableau dans un autre ou de copier une partie d’un tableau dans un autre tableau, éventuellement à une position précise.
• concat() permet de concaténer (d’amalgamer)  deux tableaux.
• reverse() permet d’inverser l’ordre des éléments d’une liste.
• sort() permet de classer les éléments d’une liste (par ordre numérique ou alphabétique).
• splice(), montré plus haut, permet d’ajouter un ou plusieurs éléments à un emplacement précis d’une liste.
• subset() permet d’enlever un ou plusieurs éléments à un emplacement précis d’une liste.
• println() permet d’afficher le contenu d’une liste dans la zone de texte de processing.

Signalons à toutes fins utiles qu’il existe une manière alternative pour créer et manipuler des tableaux qui est de recourir directement à la classe Java ArrayList. Cette méthode est assez souple, la classe ArrayList permettant d’utiliser des commandes telles que contains() (pour vérifier si un élément se trouve dans la liste) ou indexOf() pour vérifier à quelle position dans la liste se trouve un élément connu. Le mode d’emploi de ArrayList se trouve dans les pages de documentation de Java.

Dans la programmation orientée objet, la syntaxe des commandes relatives aux listes est la même mais impose une syntaxe redondante. Ainsi, si je veux créer un tableau de valeurs entières nommé liste et contenant les valeurs 0, 1, 2, 3 puis y ajouter la valeur 4, je dois écrire :

int[] liste = {0,1,2,3};
liste = append(liste, 4);

En revanche, si j’utilise une classe d’objet inventée par moi-même, par exemple la classe « bille », je devrais utiliser la commande append() comme suit :

mesBilles = (bille[]) append (mesBilles, new bille());

…Mais nous verrons cela dans le prochain article qui est justement consacré à la programmation orientée objet.