Quelles sont les méthodes d'itération sur les…

En Java, il existe plusieurs façons d'itérer sur des collections:

Boucle for avec index (pour les collections supportant l'accès par index, comme ArrayList, LinkedList):
Convient pour les collections où l'accès par index est efficace.

// Exemple d'itération sur ArrayList
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

Boucle for améliorée (boucle for-each):
La méthode la plus courante et pratique pour la plupart des cas. Convient à toutes les collections implémentant Iterable.

// Exemple d'itération sur ArrayList avec for-each
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (String element : list) {
    System.out.println(element);
}

Utilisation de l'itérateur (Iterator):
Méthode plus flexible permettant de supprimer des éléments pendant l'itération. Convient à toutes les collections.

// Exemple d'itération avec Iterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    // Il est possible de supprimer des éléments en toute sécurité
    // if (element.equals("B")) {
    //     iterator.remove();
    // }
}

Utilisation de ListIterator (pour les listes):
Itérateur spécialisé pour les collections implémentant List. Permet de naviguer dans les deux sens, ainsi que d'ajouter et de modifier des éléments.

// Exemple d'itération avec ListIterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    System.out.println(element);
}
// Exemple d'itération en arrière
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

Streams API (à partir de Java 8):
Approche fonctionnelle utilisant des expressions lambda. Permet d'effectuer des opérations sur les éléments de la collection (filtrage, transformation, etc.) de manière déclarative. L'itération se fait "en interne" dans le flux.

// Exemple d'itération avec Streams API
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

list.stream()
    .forEach(element -> System.out.println(element));

// Exemple avec filtrage et transformation
// list.stream()
//     .filter(element -> element.startsWith("A"))
//     .map(String::toLowerCase)
//     .forEach(System.out::println);

Le choix de la méthode dépend de la tâche spécifique, du type de collection et des performances requises. Pour la plupart des cas, la boucle for améliorée est la plus pratique. Si la suppression d'éléments pendant l'itération est nécessaire, utilisez Iterator. Pour les listes nécessitant une itération bidirectionnelle, ListIterator est approprié. L'API Streams offre de puissantes capacités pour traiter les données de manière déclarative.

Quelles sont les méthodes d'itération sur les collections en Java?