Façons d'itérer sur une liste en Java

Étant un peu nouveau dans le langage Java, j'essaie de me familiariser avec toutes les façons (ou au moins celles non pathologiques) que l'on pourrait parcourir à travers une liste (ou peut-être d'autres collections) et les avantages ou les inconvénients de chacun.

Étant donné un List<E> listobjet, je connais les façons suivantes de parcourir tous les éléments:

De base pour la boucle (bien sûr, il existe également des boucles while/ équivalentes do while)

// Not recommended (see below)!
for (int i = 0; i < list.size(); i++) {
    E element = list.get(i);
    // 1 - can call methods of element
    // 2 - can use 'i' to make index-based calls to methods of list

    // ...
}

Remarque: Comme @amarseillan l'a souligné, ce formulaire est un mauvais choix pour itérer sur Lists, car l'implémentation réelle de la getméthode peut ne pas être aussi efficace que lors de l'utilisation d'un Iterator. Par exemple, les LinkedListimplémentations doivent traverser tous les éléments précédant i pour obtenir le i-ème élément.

Dans l'exemple ci-dessus, l' Listimplémentation n'a aucun moyen de "sauver sa place" pour rendre les futures itérations plus efficaces. Pour un, ArrayListcela n'a pas vraiment d'importance, car la complexité / le coût de getest un temps constant (O (1)) tandis que pour un LinkedListil est proportionnel à la taille de la liste (O (n)).

Pour plus d'informations sur la complexité de calcul des Collectionsimplémentations intégrées , consultez cette question .

Amélioré pour la boucle (bien expliqué dans cette question )

for (E element : list) {
    // 1 - can call methods of element

    // ...
}

Itérateur

for (Iterator<E> iter = list.iterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list

    // ...
}

ListIterator

for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list
    // 3 - can use iter.add(...) to insert a new element into the list
    //     between element and iter->next()
    // 4 - can use iter.set(...) to replace the current element

    // ...
}

Java fonctionnel

list.stream().map(e -> e + 1); // Can apply a transformation function for e

Iterable.forEach , Stream.forEach , ...

(Une méthode de carte de l'API Stream de Java 8 (voir la réponse de @ i_am_zero).)

Dans Java 8, les classes de collection qui implémentent Iterable(par exemple, tous les Lists) ont désormais une forEachméthode, qui peut être utilisée à la place de l' instruction for loop illustrée ci-dessus. (Voici une autre question qui fournit une bonne comparaison.)

Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
//     (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
//     being performed with each item.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).

Quels autres moyens existe-t-il, le cas échéant?

(BTW, mon intérêt ne découle pas du tout d'un désir d' optimiser les performances ; je veux juste savoir quelles formes sont à ma disposition en tant que développeur.)

Les trois formes de bouclage sont presque identiques. La forboucle améliorée :

for (E element : list) {
    . . .
}

est, selon la spécification du langage Java , identique en effet à l'utilisation explicite d'un itérateur avec une forboucle traditionnelle . Dans le troisième cas, vous ne pouvez modifier le contenu de la liste qu'en supprimant l'élément courant et, ensuite, uniquement si vous le faites via la removeméthode de l'itérateur lui-même. Avec l'itération basée sur un index, vous êtes libre de modifier la liste de n'importe quelle manière. Cependant, l'ajout ou la suppression d'éléments antérieurs à l'index actuel risque de faire sauter vos éléments en boucle ou de traiter le même élément plusieurs fois; vous devez ajuster correctement l'index de boucle lorsque vous effectuez de telles modifications.

Dans tous les cas, elementest une référence à l'élément de liste réel. Aucune des méthodes d'itération ne copie quelque chose de la liste. Les modifications de l'état interne de elementseront toujours visibles dans l'état interne de l'élément correspondant de la liste.

Essentiellement, il n'y a que deux façons d'itérer sur une liste: en utilisant un index ou en utilisant un itérateur. La boucle for améliorée n'est qu'un raccourci syntaxique introduit dans Java 5 pour éviter l'ennui de définir explicitement un itérateur. Pour les deux styles, vous pouvez proposer des variations essentiellement triviales en utilisant for, whileou des do whileblocs, mais elles se résument toutes à la même chose (ou, plutôt, deux choses).

EDIT: Comme @ iX3 le fait remarquer dans un commentaire, vous pouvez utiliser a ListIteratorpour définir l'élément actuel d'une liste pendant que vous itérez. Vous auriez besoin d'utiliser List#listIterator()au lieu de List#iterator()pour initialiser la variable de boucle (qui, évidemment, devrait être déclarée a ListIteratorplutôt que an Iterator).

Exemple de chaque type énuméré dans la question:

ListIterationExample.java

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

La boucle de base n'est pas recommandée car vous ne connaissez pas l'implémentation de la liste.

S'il s'agissait d'une LinkedList, chaque appel à

list.get(i)

serait itérer sur la liste, entraînant une complexité temporelle de N ^ 2.

Une itération de style JDK8:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

Dans Java 8, nous avons plusieurs façons d'itérer sur les classes de collection.

Utiliser Iterable forEach

Les collections qui implémentent Iterable(par exemple toutes les listes) ont désormais une forEachméthode. Nous pouvons utiliser la référence de méthode introduite dans Java 8.

Arrays.asList(1,2,3,4).forEach(System.out::println);

Utilisation de Streams forEach et forEachOrdered

Nous pouvons également parcourir une liste en utilisant Stream comme:

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

Nous devrions préférer forEachOrderedplutôt forEachque le comportement de forEachest explicitement non déterministe alors queforEachOrdered effectue une action pour chaque élément de ce flux, dans l'ordre de rencontre du flux si le flux a un ordre de rencontre défini. Ainsi, forEach ne garantit pas que la commande sera conservée.

L'avantage des flux est que nous pouvons également utiliser des flux parallèles le cas échéant. Si l'objectif est uniquement d'imprimer les articles quelle que soit la commande, nous pouvons utiliser le flux parallèle comme:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

Je ne sais pas ce que vous considérez comme pathologique, mais permettez-moi de vous proposer quelques alternatives que vous n'auriez pas pu voir auparavant:

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

Ou sa version récursive:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

En outre, une version récursive du classique for(int i=0... :

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

Je les mentionne car vous êtes "un peu nouveau pour Java" et cela pourrait être intéressant.

Vous pouvez utiliser forEach à partir de Java 8:

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

Pour une recherche en arrière, vous devez utiliser les éléments suivants:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

Si vous voulez connaître une position, utilisez iterator.previousIndex (). Cela aide également à écrire une boucle interne qui compare deux positions dans la liste (les itérateurs ne sont pas égaux).

À droite, de nombreuses alternatives sont répertoriées. Le plus simple et le plus propre serait simplement d'utiliser l' forinstruction améliorée comme ci-dessous. Le Expressionest d'un type qui est itérable.

for ( FormalParameter : Expression ) Statement

Par exemple, pour parcourir les identifiants List <String>, nous pouvons simplement le faire,

for (String str : ids) {
    // Do something
}

Dans, java 8vous pouvez utiliser la List.forEach()méthode avec lambda expressionpour parcourir une liste.

import java.util.ArrayList;
import java.util.List;

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

Vous pouvez toujours changer les premier et troisième exemples avec une boucle while et un peu plus de code. Cela vous donne l'avantage de pouvoir utiliser le do-while:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Bien sûr, ce genre de chose peut provoquer une NullPointerException si list.size () renvoie 0, car il est toujours exécuté au moins une fois. Cela peut être corrigé en testant si l'élément est nul avant d'utiliser ses attributs / méthodes. Pourtant, il est beaucoup plus simple et plus facile d'utiliser la boucle for