pourquoi le renforcement de la boucle for plus efficace que la normale pour la boucle

C'est un peu simpliste de dire que l'amélioration de la boucle for est plus efficace. Il peut être, mais dans de nombreux cas, il est presque exactement la même chose qu'une vieille école de la boucle.

La première chose à noter est que pour les collections de la renforcée pour la boucle utilise un Iterator, donc si vous avez manuellement itérer sur une collection à l'aide d'un Iterator alors vous devriez avoir à peu près la même performance que le renforcement de la boucle for.

Un endroit où le renforcement de la boucle for est plus rapide qu'un naïvement mis en œuvre traditionnelle boucle est quelque chose comme ceci:

LinkedList<Object> list = ...;

//Loop 1:
int size = list.size();
for (int i = 0; i<size; i++) {
   Object o = list.get(i);
   ///do stuff
}

//Loop 2:
for (Object o : list) {
  //do stuff
}

//Loop 3:
Iterator<Object> it = list.iterator();
while (it.hasNext()) {
  Object o = it.next();
  //do stuff
}

Dans ce cas, la Boucle 1 sera plus lente que celle de la Boucle 2 et de la Boucle 3, car il aura à (partiellement) la traversée de la liste à chaque itération de trouver l'élément à la position i. La boucle 2 et 3, cependant ne jamais l'étape un élément de plus dans la liste, en raison de l'utilisation d'un Iterator. La boucle 2 et 3 auront aussi à peu près la même performance depuis la Boucle 3 est à peu près exactement ce que le compilateur produira lorsque vous écrivez du code dans la Boucle 2.

OriginalL'auteur Joachim Sauer

J'ai lu que l'amélioration de la boucle for est efficace qu'à la normale pour la boucle.

En fait parfois, c'est moins efficace pour le programme, mais la plupart du temps son exactement la même.

Son plus efficace pour le développeur, ce qui est souvent beaucoup plus important

Une boucle for-each est particulièrement utile lors de l'itération sur une collection.

List<String> list = 
for(Iterator<String> iter = list.iterator(); list.hasNext(); ) {
    String s = list.next();

est plus facile à écrire (mais fait la même chose que, de sorte que son pas plus efficace pour le programme)

List<String> list = 
for(String s: list) {

---

À l'aide de la "vieille" la boucle est légèrement plus efficace lors de l'accès au hasard de collecte accessible par l'index.

List<String> list = new ArrayList<String>(); //implements RandomAccess
for(int i=0, len = list.size(); i < len; i++) //doesn't use an Iterator!

À l'aide d'une boucle for-each sur une collection toujours utilise un Itérateur qui est légèrement moins efficace pour un accès aléatoire listes.

Autant que je sache, l'utilisation d'une boucle for-each est jamais plus efficace pour le programme, mais comme je l'ai dit, l'efficacité du développeur est souvent beaucoup plus important.

OriginalL'auteur Peter Lawrey

La boucle foreach est aussi efficace que ce type de boucle:

for (Iterator<Foo> it = list.iterator(); it.hasNext(); ) {
     Foo foo = it.next();
     ...
}

parce que c'est strictement équivalent.

Si vous itérer sur une liste à l'aide de

int size = list.size();
for (int i = 0; i < size; i++) {
    Foo foo = list.get(i);
    ...
}

Puis la boucle foreach va avoir des performances équivalentes que votre boucle, mais seulement pour ArrayList. Dans le cas d'une LinkedList, votre boucle sera catastrophique de la performance, car à chaque iteratioon, il devra parcourir tous les nœuds de la liste jusqu'à ce qu'il arrive à la iélément th.

La boucle foreach (ou la boucle basée sur un itérateur, qui est la même), n'ont pas ce problème, puisque l'itérateur maintient une référence vers le nœud courant et va tout simplement à l'autre, à chaque itération. C'est le bast choix, car il fonctionne très bien avec tous les types de listes. Il exprime aussi l'intention plus clairement, et il est plus sûr parce que vous ne prenez pas le risque d'un accroissement de l'indice à l'intérieur de la boucle, ou d'utiliser le mauvais indice dans le cas de boucles imbriquées.

OriginalL'auteur JB Nizet

toutes les réponses sont bonnes,et je pense ne plus les réponses sont nécessaires, mais je veux juste souligner que:

Le renforcement de l'énoncé peut être utilisé seulement à obtain array elements

il ne peut pas être utilisé à modify elements.

Si votre programme a besoin de modifier des éléments, utiliser le traditionnel contre-contrôlé for déclaration.

prendre un coup d'oeil

int[] array = { 1, 2, 3, 4, 5 };
for (int counter = 0; counter < array.length; counter++)
    array[counter] *= 2;

Nous ne pouvions pas utiliser le enhanced for déclaration parce que nous sommes modifying the array’s elements.

OriginalL'auteur Basheer AL-MOMANI