Java: meilleur moyen de parcourir une collection (ici, ArrayList)
Aujourd’hui, j’étais en train de coder avec bonheur quand je suis arrivé à un morceau de code que j’avais déjà utilisé des centaines de fois:
Itérer dans une collection (ici ArrayList)
pour une raison quelconque, j'ai effectivement examiné les options d'auto-complétion d'Eclipse et je me suis demandé:
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'Iterator 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. Ceci est fondamentalement équivalent aux deux autres variantes pour ArrayLists, mais sera vraiment lent si vous utilisez un LinkedList.
La seconde est utile lorsque vous n’avez pas besoin de l’index de l’élément mais que vous devez peut-être supprimer les éléments au fur et à mesure de votre itération. Mais cela a l’inconvénient d’être un peu trop bavard à l’OMI.
La troisième version est aussi mon choix préféré. Il est court et fonctionne dans tous les cas où vous n'avez besoin d'aucun index ni de l'itérateur sous-jacent (c'est-à-dire que vous n'accédez qu'à des éléments, sans les supprimer ni en modifiant la Collection de quelque manière que ce soit - ce qui est le cas le plus courant).
Tous ont leurs propres utilisations:
Si vous avez un itératif et devez traverser inconditionnellement à tous:
pour (iterable_type iterable_element: collection)
Si vous avez un itératif mais que vous devez traverser conditionnellement:
pour (itérateur Iterator = collection.iterator (); iterator.hasNext ();)
Si la structure de données n'implémente pas iterable:
pour (int i = 0; i <collection.length; i ++)
Il existe également des utilitaires stream () de collections avec Java 8
collection.forEach((temp) -> {
System.out.println(temp);
});
ou
collection.forEach(System.out::println);
Plus d'informations sur le flux Java 8 et les collections pour les merveilles lien
Aucun d'entre eux n'est "meilleur" que les autres. La troisième est, à mes yeux, plus lisible, mais pour quelqu'un qui n'utilise pas les langues précédentes, cela peut sembler étrange (ils pourraient préférer la première). Tous les trois sont assez clairs pour quiconque comprend Java, alors choisissez celui qui vous rend le meilleur pour le code.
Le premier est le plus fondamental, donc le motif 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 des cas plus complexes (par exemple, vous devez avoir accès à l'index actuel ou filtrer la liste), les premier et deuxième cas peuvent alors 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 offre de meilleures performances (comme ArrayList implémente l’interface RandomAccess). Conformément à la doc Java doc, une implémentation de liste doit implémenter l'interface RandomAccess si, pour les instances typiques de la classe, cette boucle:
for (int i=0, n=list.size(); i < n; i++)
list.get(i);
court plus vite que cette boucle:
for (Iterator i=list.iterator(); i.hasNext(); )
i.next();
J'espère que ça 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);
}