Java: meilleur moyen d'itérer dans une collection (ici ArrayList)

Aujourd'hui, je codais volontiers quand je suis arrivé à un morceau de code que j'ai déjà utilisé des centaines de fois:

Itérer dans une collection (ici ArrayList)

Pour une raison quelconque, j'ai en fait examiné les options de saisie semi-automatique d'Eclipse et cela m'a fait me demander:

Dans quels cas les boucles suivantes sont-elles meilleures à utiliser que les autres?

La boucle d'index de tableau classique:

for (int i = 0; i < collection.length; i++) {
  type array_element = collection.get(index);
}

L'itérateur hasNext () / next ():

for (Iterator iterator = collection.iterator(); iterator.hasNext();) {
  type type = (type) iterator.next();   
}

Et mon préféré parce que c'est si simple à écrire:

for (iterable_type iterable_element : collection) {

}

Le premier est utile lorsque vous avez également besoin de l'index de l'élément. C'est fondamentalement équivalent aux deux autres variantes pour ArrayLists, mais sera vraiment lent si vous utilisez un LinkedList.

Le second est utile lorsque vous n'avez pas besoin de l'index de l'élément mais que vous devrez peut-être supprimer les éléments au fur et à mesure que vous itérez. Mais cela a l'inconvénient d'être un peu trop verbeux de l'OMI.

La troisième version est également mon choix préféré. Il est court et fonctionne pour tous les cas où vous n'avez besoin d'aucun index ou de l'itérateur sous-jacent (c'est-à-dire que vous n'accédez qu'aux éléments, ne les supprimez pas ou ne modifiez pas le Collectionde quelque manière que ce soit - ce qui est le cas le plus courant).

Tous ont leurs propres usages:

1. Si vous avez un itérable et que vous devez les parcourir sans condition:

   pour (iterable_type iterable_element: collection)

2. Si vous avez un itérable mais que vous devez le traverser conditionnellement:

   for (Itérateur itérateur = collection.iterator (); iterator.hasNext ();)

3. Si la structure de données n'implémente pas l'itérable:

   pour (int i = 0; i <collection.length; i ++)

Il existe également un utilitaire stream () de collections avec Java 8

collection.forEach((temp) -> {
            System.out.println(temp);
});

ou

collection.forEach(System.out::println);

Plus d'informations sur le lien Java 8 stream et collections for wonderers

Aucun d'eux n'est «meilleur» que les autres. Le troisième est, pour moi, plus lisible, mais pour quelqu'un qui n'utilise pas foreach, cela peut paraître étrange (ils préfèrent peut-être le premier). Tous les 3 sont assez clairs pour quiconque comprend Java, alors choisissez celui qui vous permet de vous sentir mieux dans le code.

Le premier est le plus basique, c'est donc le modèle le plus universel (fonctionne pour les tableaux, tous les itérables auxquels je peux penser). C'est la seule différence à laquelle je peux penser. Dans les cas plus compliqués (par exemple, vous devez avoir accès à l'index actuel, ou vous devez filtrer la liste), les premier et deuxième cas peuvent avoir plus de sens, respectivement. Pour le cas simple (objet itérable, pas d'exigences particulières), le troisième semble le plus propre.

La première option est de meilleures performances (car ArrayList implémente l'interface RandomAccess). Selon la documentation java, une implémentation de List doit implémenter l'interface RandomAccess si, pour des instances typiques de la classe, cette boucle:

 for (int i=0, n=list.size(); i < n; i++)
     list.get(i);

s'exécute plus vite que cette boucle:

 for (Iterator i=list.iterator(); i.hasNext(); )
     i.next();

J'espère que cela aide. La première option serait lente pour les listes d'accès séquentielles.

Voici un exemple

Query query = em.createQuery("from Student");
             java.util.List list = query.getResultList();
             for (int i = 0; i < list.size(); i++) 
             {

                 student = (Student) list.get(i);
                 System.out.println(student.id  + "  " + student.age + " " + student.name + " " + student.prenom);

             }