Processing > ArrayList
Contents (hide)
1. Introduction
Un ArrayList est une classe qui se comporte comme un tableau. Contrairement à un tableau, un ArrayList peut changer de taille dynamiquement et peut contenir des types de données différentes.
La documentation Processing se trouve ici 
, mais elle est assez brève. La documentation complète se trouve sur le site de Sun ici 
.
2. Création
ArrayList <type> maListe = new ArrayList();
3. Ajout d'élément
maListe.add(donnée);
4. Taille
int taille = maListe.size();
5. Recueillir un élément
maClasse monObjet = maListe.get(index);
6. Traverser un ArrayList
maClasse monObjet;
for (int i=0; i < maListe.size() ; i=i+1 ) {
monObjet = maListe.get(i);
// Faire qqch avec monObjet
}
7. Suppression d'un élément spécifique
maListe.remove(index);
8. Suppression d'éléments dans une boucle
Si des éléments sont retirés d'un ArrayList traversé par une boucle, cette boucle doit être parcourue à partir du dernier élément jusqu'au premier (c'est à dire à l'envers). Ceci évite la redondance des valeurs d'index.
L'exemple suivant retire aléatoirement des éléments d'un ArrayList. La boucle traverse l'ArrayList du dernier élément au premier :
for ( int i = maListe.size()-1 ; i>=0 ; i=i-1 ) {
if ( random(1) > 0.5 ) {
maListe.remove(index);
}
}
9. Comparaison d'éléments entre eux
Dans cet exemple, "liste" est un ArrayList qui contient des objets de type Element. Chaque itération de la boucle imbriquée suivante permet de comparer tous les éléments entre eux tout en évitant les répétitions.
La déclaration et l'assignation de la liste et des éléments:
class Element {
float x,y;
Element(float x, float y) {
this.x = x;
this.y = y;
}
}
ArrayList liste = new ArrayList();
for ( int i =0; i < 10 ; i++) {
liste.add( new Element( random(width), random(height) );
}
La boucle de comparaison:
for ( int i =0 ; i < liste.size() ; i++ ) {
Element element_i = (Element) list.get(i);
for ( int j =i+1 ; j < liste.size() ; j++ ) {
Element element_j = (Element) list.get(j);
// Effectuer une comparaison entre element_i et element_j ici.
// Par exemple, calculer la distance entre les deux elements:
float distance = dist( element_i.x , element_i.y , element_j.x , element_j.y);
}
Exemple: Cercles (collisions) 
9.1 Avec suppression
Lorsqu'il est possible que le code supprime des éléments d'une liste traversée par une boucle, il faut que la liste soit traversée à l'envers. C'est à dire à partir du dernier élément jusqu'au premier.
La déclaration et l'assignation de la liste et des éléments:
class Element {
float x,y;
Element(float x, float y) {
this.x = x;
this.y = y;
}
}
ArrayList liste = new ArrayList();
for ( int i =0; i < 10 ; i++) {
liste.add( new Element( random(width), random(height) );
}
La boucle de comparaison et de suppression:
for ( int i =liste.size()-2 ; i >= 0 ; i-- ) {
boolean supprimer_i = false;
Element element_i = (Element) list.get(i);
for ( int j =liste.size()-1 ; j > i ; j-- ) {
Element element_j = (Element) list.get(j);
// Déterminer s'il faut supprimer les éléments pointés par i ou j.
// Si les éléments doivent être supprimés,
// supprimer j et ensuite indiquer que i doit être supprimé avec:
// supprimer_i = true;
// Par exemple, supprimer les éléments s'ils sont à une distance de 20 pixels:
if ( dist( element_i.x , element_i.y , element_j.x , element_j.y) < 20 ) {
liste.remove(j);
supprimer_i = true;
}
}
}
if ( supprimer_i == true ) {
// supprimer i si j a été supprimé
liste.remove(i);
}
}
Exemple: Cercles (collisions et suppressions)
10. Trier un ArrayList selon un attribut
10.1 Avec une boucle imbriquée
// Creer une classe simple.
class UneClasse {
int y;
UneClasse(int y) {
this.y = y;
}
}
// Creer l'ArrayList nonTries.
ArrayList nonTries;
nonTries = new ArrayList();
// Ajouter des elements aleatoires et non triés a l'ArrayList nonTries.
for ( int i =0 ; i < 10 ; i++) {
UneClasse u = new UneClasse( 45 ) ;
nonTries.add( new UneClasse( floor(random(200)) ) );
}
// Imprimer la liste nonTries.
print("Non triées");
for ( int i = 0; i < nonTries.size() ; i++ ) {
UneClasse u_i = (UneClasse) nonTries.get(i);
print(", "+u_i.y);
}
println();
// Le bloc de code suivant trie l'ArrayList selon
// l'attribut "y" des objets.
ArrayList tries = new ArrayList();
for ( int i = 0; i < nonTries.size() ; i++ ) {
UneClasse u_i = (UneClasse) nonTries.get(i);
int j = 0;
for ( ; j < tries.size() ; j++ ) {
UneClasse u_j = (UneClasse) tries.get(j);
if ( u_i.y < u_j.y ) break;
}
tries.add(j,u_i);
}
// L'ArrayList tries est maintenant triée selon l'attribut
// "y" des objets.
nonTries = tries;
// Imprimer l'ArrayList tries
print("Triées");
for ( int i = 0; i < tries.size() ; i++ ) {
UneClasse u_i = (UneClasse) tries.get(i);
print(", "+u_i.y);
}
10.2 Avec un "comparator"
import java.util.Comparator;
// Creer une classe simple.
class UneClasse {
int y;
UneClasse(int y) {
this.y = y;
}
}
// Creer la methode de comparaison
class ComparerY implements Comparator {
// Trier selon l'attribut y des objets
public final int compare( Object a, Object b ) {
return ((( UneClasse ) a ).y > ( ( UneClasse ) b ).y ) ? 1 : -1;
}
}
void setup() {
// Creer l'ArrayList nonTries.
ArrayList nonTries;
nonTries = new ArrayList();
// Ajouter des elements aleatoires et non triés a l'ArrayList nonTries.
for ( int i =0 ; i < 10 ; i++) {
UneClasse u = new UneClasse( 45 ) ;
nonTries.add( new UneClasse( floor(random(200)) ) );
}
// Imprimer la liste nonTries.
print("Non triées");
for ( int i = 0; i < nonTries.size() ; i++ ) {
UneClasse u_i = (UneClasse) nonTries.get(i);
print(", "+u_i.y);
}
println();
// Le bloc de code suivant trie l'ArrayList selon
// l'attribut "y" des objets avec un comparateur
Collections.sort( nonTries, new ComparerY() );
// L'ArrayList nonTries est maintenant triée selon l'attribut
// "y" des objets.
// Imprimer l'ArrayList nonTries qui est maintenant triée
print("Triées");
for ( int i = 0; i < nonTries.size() ; i++ ) {
UneClasse u_i = (UneClasse) nonTries.get(i);
print(", "+u_i.y);
}
}