Quelle est la meilleure façon d'itérer sur la liste

J'ai travaillé à peu près sur de la collection, mais j'ai quelques doutes.

Je suis conscient de ce que nous pouvons itérer liste avec itérateur.

Une autre manière, c'est que nous pouvons traverser comme ci-dessous:

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

Ici, je pense qu'il y a problème à chaque fois qu'il fera appel de la liste.taille() qui va construire l'arbre tout entier qui auront un impact sur les performances.

J'ai pensé à une autre solution, par exemple:

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

Je pense que cela peut résoudre le problème. Je ne suis pas beaucoup plus exposés à enfiler. Je pense que whetherthis devrait être le droit de l'approche ou pas.

Une autre façon de pensée est comme:

for (Object obj; list){

}

Avec cette nouvelle pour la boucle, je pense que le compilateur vérifie à nouveau la taille de la liste.

Veuillez vous donner la meilleure solution ou alternative de la performance efficace. Je vous remercie pour votre aide.

Pourquoi ne list.size() la construction d'un arbre?
La JVM doit gérer le cache de la valeur de la liste.size() de sorte qu'il n'a pas vraiment d'appeler la fonction à chaque fois.

OriginalL'auteur Nimesh | 2015-04-11

  1. 4

    Appel size() à chaque itération n'est pas vraiment un problème. Cette opération est O(1) pour toutes les collections que je connais: size() retourne simplement la valeur d'un champ de la liste, la tenue de sa taille.

    Le principal problème de la première manière est la répétition de l'appel à get(i). Cette opération est O(1) pour une liste de tableaux, mais il est O(n) pour une LinkedList, rendant l'ensemble de l'itération O(n2) au lieu de O(n): get(i) forces de la liste pour démarrer à partir du premier élément de la liste (ou la dernière), et d'aller vers le nœud suivant jusqu'à ce que le i-ème élément.

    À l'aide d'un itérateur, ou à l'aide d'une boucle foreach (qui utilise en interne un itérateur), garantit que le moyen le plus approprié de l'itération est utilisé, en raison de l'itérateur sait sur la façon dont la liste est mise en œuvre et la meilleure façon de passer d'un élément à l'autre.

    BTW, c'est aussi le seul moyen pour parcourir par le biais de non-indexé collections, comme des Ensembles. Donc tu ferais mieux de prendre l'habitude d'utiliser ce genre de boucle.

    Et qu'en est-il pour la boucle?
    c'est ce que je veux dire avec "boucle foreach". Il utilise un itérateur interne. J'ai tendance à éviter d'appeler la "nouvelle pour la boucle", comme il n'est pas nouveau du tout. C'est l'âge de 10 ans.
    Oui mais pour l'identité perspective, nous appelons de nouveau pour la boucle
    Le bon terme, utilisé par le Langage Java Specification, est "Le renforcement de l'énoncé". Mais croyez-le ou pas, il est communément appelé la boucle foreach. Voir par exemple: docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html
    howtodoinjava.com/2013/03/26/... ce blog dit que itérateur est lent

    OriginalL'auteur JB Nizet

  2. 5

    Pour votre exemple est la meilleure façon:

    for (Object obj: list){

}

    C'est le même comme dans la version java < 1.5: 

    for (Iterator it = hs.iterator() ; it.hasNext() ; ){}

    Il utiliser l'itérateur de la collecte. Vous avez réellement n'avez pas besoin de la taille de la collection. L' .méthode size() est devrait en fait de ne pas construire de l'arbre, mais .get() peuvent boucles de l'élément donné. .get() et .size() les méthodes dépendent de la Liste de mise en œuvre. .get() ArrayList doit être fait en O(1) de la complexité et de ne pas O(n)

    Mise à JOUR

    Dans java 8, vous pouvez utiliser:

    myList.forEach{ Object elem -> 
 //do something
}

    OriginalL'auteur CyberAleks

  3. 1

    Le meilleur moyen pour parcourir la liste en termes de performance serait d'utiliser des itérateurs ( votre deuxième approche utilisant foreach ).
    Si vous êtes en utilisant la liste.get(i), c'est la performance dépendra de la mise en œuvre de la liste. Pour la liste de tableaux liste.get(i) est O(1) où, comme il est O(n) pour LinkedList.

    Aussi, liste.size() est O(1) et ne devrait pas avoir d'impact sur les performances.

    ce serait le moment de la complexité de forEach ?. Si son O(n) pourquoi ne pas concepteurs de O(log n) ?

    OriginalL'auteur Mohit Gupta

  4. 1
    for (Object obj: list){

}

    Code ci-dessus, pour moi, est le meilleur moyen, c'est propre et peut être lu facilement.

    Le forEach dans Java 8 est sympa aussi.

    OriginalL'auteur shepard23