Itérer avec une boucle for ou une boucle while?

Question

Je vois souvent du code comme:

Iterator i = list.iterator();
while(i.hasNext()) {
    ...
}

mais j’écris cela (lorsque Java 1.5 n’est pas disponible ou ne peut pas être utilisé pour chacun d’eux) comme:

for(Iterator i = list.iterator(); i.hasNext(); ) {
    ...
}

parce que

• il est plus court
• Cela conserve i dans une portée plus petite
• Cela réduit les risques de confusion. ( i est-il utilisé en dehors de la tandis que? Où i est-il déclaré?)

Je pense que le code doit être aussi simple à comprendre que possible, de sorte que je n'ai à créer que du code complexe pour faire des choses complexes. Qu'est-ce que tu penses? Quel est le meilleur?

De: http://jamesjava.blogspot.com/2006/04/iterating. html

Answer 1

Je préfère la boucle for car elle définit également la portée de l'itérateur sur la boucle for.

Answer 2

Il existe des utilisations appropriées pour les constructions while, for et foreach:

• while - Utilisez cette option si vous effectuez une itération et que le facteur déterminant pour la mise en boucle ou non repose uniquement sur une condition. Dans cette construction de boucle, conserver un index n’est qu’une préoccupation secondaire; tout devrait être basé sur la condition

• pour - Utilisez ceci si vous faites une boucle et que votre préoccupation principale est l'index du tableau / collection / liste. Il est plus utile d’utiliser un pour si vous êtes de toute façon plus susceptible de parcourir tous les éléments, et dans un ordre particulier (par exemple, revenir en arrière dans une liste triée, par exemple).

• foreach - Utilisez cette option si vous devez simplement parcourir votre collection, quel que soit son ordre.

Évidemment, il existe des exceptions à ce qui précède, mais c’est la règle générale que j’utilise pour décider lequel utiliser. Cela dit, j’ai tendance à utiliser foreach plus souvent.

Answer 3

Pourquoi ne pas utiliser la construction for-each? (Je n'ai pas utilisé Java depuis un moment, mais cela existe en C # et je suis presque sûr que Java 1.5 en a aussi):

List<String> names = new ArrayList<String>();
names.add("a");
names.add("b");
names.add("c");

for (String name : names)
    System.out.println(name.charAt(0));

Answer 4

Je pense que la portée est le plus gros problème ici, comme vous l'avez souligné.

Dans le champ "While". Par exemple, l'itérateur est déclaré en dehors de la boucle, il continuera donc d'exister une fois la boucle terminée. Cela peut causer des problèmes si ce même itérateur est utilisé à nouveau ultérieurement. Par exemple. vous pouvez oublier de l'initialiser avant de l'utiliser dans une autre boucle.

Dans le " for " Par exemple, l'itérateur est déclaré à l'intérieur de la boucle, sa portée est donc limitée à la boucle. Si vous essayez de l'utiliser après la boucle, vous obtiendrez une erreur du compilateur.

Answer 5

si vous n'utilisez qu'une seule fois l'itérateur et le jetez, la deuxième forme est préférable; sinon vous devez utiliser le premier formulaire

Answer 6

IMHO, la boucle pour est moins lisible dans ce scénario si vous regardez ce code du point de vue de la langue anglaise. Je travaille sur un code dans lequel l'auteur abuse de la boucle pour , et ce n'est pas joli. Comparez les éléments suivants:

for (; (currUserObjectIndex < _domainObjectReferences.Length) && (_domainObjectReferences[currUserObjectIndex].VisualIndex == index); ++currUserObjectIndex)
    ++currNumUserObjects;

vs

while (currUserObjectIndex < _domainObjectReferences.Length && _domainObjectReferences[currUserObjectIndex].VisualIndex == index)
{
    ++currNumUserObjects;
    ++currUserObjectIndex;
}

Answer 7

Je conviens que le " for " La boucle est plus claire et plus appropriée lors de l'itération.

Le " While " La boucle est appropriée pour l'interrogation ou lorsque le nombre de boucles pour satisfaire les conditions de sortie changera en fonction de l'activité à l'intérieur de la boucle.

Answer 8

Ce n’est pas que cela ait probablement de l'importance dans ce cas, mais les compilateurs, les machines virtuelles et les processeurs utilisent normalement des techniques d'optimisation spécifiques qu'ils utilisent sous le capot pour améliorer les performances des boucles (et dans un proche parallèle parallèle). faites-le avec des boucles while (car il est plus difficile de déterminer comment cela va fonctionner). Mais dans la plupart des cas, la clarté du code devrait avoir une incidence sur l'optimisation.

Answer 9

En utilisant la boucle for, vous pouvez travailler avec une seule variable, car elle définit la portée de la variable pour une boucle en cours de travail uniquement. Toutefois, cela n’est pas possible dans la boucle while . Par exemple:
int i; pour (i = 0; in1; i ++) faire quelque chose ..

pour (i = 0; i n2; i + = 2) faire quelque chose.

Donc après la 1ère boucle, i = n1-1 à la fin. Mais lorsque vous utilisez la deuxième boucle, vous pouvez régler à nouveau i sur 0.   Cependant

int i = 0;

while (i inférieur à la limite) {faire quelque chose ..; i ++; }

Par conséquent, i est défini sur limit-1 à la fin. Vous ne pouvez donc pas utiliser le même i dans une autre boucle while.

Answer 10

Les deux vont bien. J'utilise pour () moi-même et je ne sais pas s'il y a des problèmes de compilation. Je pense qu’ils sont optimisés à peu près à la même chose.

Answer 11

Je conviens que la boucle for devrait être utilisée chaque fois que possible, mais il existe parfois une logique plus complexe qui contrôle l'itérateur dans le corps de la boucle. Dans ce cas, vous devez y aller avec while.

Answer 12

J'étais la boucle for pour plus de clarté. Bien que j'utilise la boucle while lorsque je suis confronté à une condition indéterministe.

Answer 13

Les deux vont bien, mais souvenez-vous que parfois, accéder directement à l'Iterator est utile (par exemple, si vous supprimez des éléments qui correspondent à une certaine condition - vous obtiendrez une ConcurrentModificationException si vous faites collection.remove (o) dans un for ( T o: collection) en boucle).

Je préfère écrire la syntaxe for (blah: blah) [foreach] presque tout le temps, car elle me semble plus naturellement lisible. Le concept des itérateurs en général n'a pas vraiment de parallèle en dehors de la programmation

Answer 14

Les universités ont tendance à préférer la boucle while, car elle permet de raisonner de manière moins complexe sur les programmes. J'ai tendance à préférer les structures for- ou foreach-loop car elles facilitent la lecture du code.

Answer 15

Bien que les deux fonctionnent vraiment bien, j’ai tendance à utiliser le premier exemple car il est plus facile à lire.

Il y a moins d'opérations qui se produisent sur chaque ligne avec la boucle while (), ce qui facilite le code pour un débutant qui comprend ce qui se passe.

Ce type de construction me permet également de regrouper les initialisations dans un emplacement commun (en haut de la méthode), ce qui simplifie également les commentaires, ainsi que la conceptualisation pour quelqu'un qui le lit pour la première fois.