Comment obtenir de la boucle de courant de l'index lors de l'utilisation d'un Itérateur?

Je suis en utilisant un Itérateur pour parcourir une collection
et je veux obtenir le courant de l'élément d'index.

Comment puis-je le faire?

double possible de Est-il un moyen d'accéder à une itération vente libre en Java pour-chaque tour de boucle?
Je ne pense pas qu'ils sont en double. Cette question est à poser à l'aide d'Itérateur, l'autre est à l'aide de boucle for-each. Les deux questions sont résolues par une approche similaire, de sorte que les réponses sont en double pas la question.

InformationsquelleAutor Mahmoud Saleh | 2010-07-25

83

Utiliser votre propre variable et l'incrémenter dans la boucle.
- Mais aussi consultez @mateusz-dymczyk suggestion au sujet de it.nextIndex(). Utile lorsque la collection est une Liste de.
InformationsquelleAutor Chris Diver
92

J'ai eu la même question et a découvert à l'aide d'un ListIterator travaillé. Similaire au test ci-dessus:
```
List<String> list = Arrays.asList("zero", "one", "two");

ListIterator iter = list.listIterator();

while (iter.hasNext()) {
    System.out.println("index: " + iter.nextIndex() + " value: " + iter.next());
}
```
Assurez-vous que vous appelez la nextIndex AVANT de vous apprendre la méthode next().
- Merci pour la mention de 'assurez-vous que vous appelez la nextIndex AVANT de vous apprendre la méthode next()'
InformationsquelleAutor Paul
27

Voici un moyen de le faire à l'aide de votre propre variable et de le garder concis:
```
List<String> list = Arrays.asList("zero", "one", "two");

int i = 0;
for (Iterator<String> it = list.iterator(); it.hasNext(); i++) {
    String s = it.next();
    System.out.println(i + ": " + s);
}
```
De sortie (vous l'aurez deviné):
```
0: zero
1: one
2: two
```
L'avantage est que vous n'avez pas d'incrément de votre index à l'intérieur de la boucle (bien que vous devez être prudent de n'appeler qu'Itérateur#prochaine une fois par boucle - just do it en haut).
- Si vous créez l'itérateur vous-même, vous pouvez utiliser un ListIterator ainsi et n'ont pas besoin de séparer les variables int.
- Si vous utilisez un "statiques import" pour les Tableaux.asList, alors vous pouvez simplement écrire asList("zero", "one", "two")
- c'est exactement la façon dont je l'ai fait avant que j'ai lu la réponse de Paul. Je déconseille vivement votre chemin, parce que je ne vois aucun avantage à elle. Pensez-vous qu'il est un avantage (à l'exception de celui mentionné). Pourquoi n'utilisez-vous pas une boucle for-each? La définition de l'Itérateur explicitement n'est pas nécessaire, si vous utilisez votre propre variable.
- juste si vous avez besoin d'un Itérateur (comme par question, par exemple, de passer à la bibliothèque), dont l'exemple ne montre pas. Dans cet exemple, vous avez une variable en dehors de la boucle et de la nécessité d'être prudent de faire appel de #la prochaine fois. Dans l'exemple de Paul il n'y a pas de variables en dehors de la boucle, mais vous devez être prudent de faire appel #prochaine et #nextIndex ensemble une fois (et dans la pratique, si elle est utilisée plus d'une fois, ils allaient être tiré dans les variables locales, dont l'exemple ne montre pas).
InformationsquelleAutor Tom Clift

Vous pouvez utiliser ListIterator à faire le décompte:

final List<String> list = Arrays.asList("zero", "one", "two", "three");

for (final ListIterator<String> it = list.listIterator(); it.hasNext();) {
    final String s = it.next();
    System.out.println(it.previousIndex() + ": " + s);
}

InformationsquelleAutor Robert Klemme

10

Ce genre de collection? Si c'est une mise en œuvre de la Liste de l'interface alors vous pouvez simplement utiliser it.nextIndex() - 1.

InformationsquelleAutor Mateusz Dymczyk
4

Utiliser un ListIterator pour parcourir la Collection. Si la Collection n'est pas une Liste pour commencer à utiliser Arrays.asList(Collection.toArray()) pour la transformer en une Liste de la première.

InformationsquelleAutor Jatin
2

Utiliser un int et l'incrémenter au sein de votre boucle.

InformationsquelleAutor Florian Reischl
2

juste faire quelque chose comme ceci:
```
        ListIterator<String> it = list1.listIterator();
        int index = -1;
        while (it.hasNext()) {
            index++;
            String value = it.next();
            //At this point the index can be checked for the current element.

        }
```
- Appel indexOf() nécessitera une analyse supplémentaire de la liste des périphériques. Il sera plus rapide de simplement incrémenter un compteur local.
- d'accord. ce n'est pas la solution la plus efficace.
- Ressemble à la mise à jour de l'exemple pour être plus efficace.
- je l'ai fait et pourtant j'ai 3 votes contre 🙁
InformationsquelleAutor Sunny
1

Voir ici.

iterator.nextIndex() serait de fournir de l'indice de l'élément qui serait retourné par l'appel suivant de next().
- L'interface Iterator n'a PAS nextIndex() la méthode. Vous devez utiliser explicitement un ListIterator, mais l'OP interrogé spécifiquement sur la Itérateur.
InformationsquelleAutor Jolly
0

Tout ce que vous devez utiliser l'itérateur.nextIndex() pour retourner à l'index actuel que l'itérateur est sur. Cela pourrait être un peu plus facile que d'utiliser votre propre variable de compteur (qui fonctionne toujours aussi).
```
public static void main(String[] args) {    
    String[] str1 = {"list item 1", "list item 2", "list item 3", "list item 4"};
    List<String> list1 = new ArrayList<String>(Arrays.asList(str1));

    ListIterator<String> it = list1.listIterator();

    int x = 0;

    //The iterator.nextIndex() will return the index for you.
    while(it.hasNext()){
        int i = it.nextIndex();
        System.out.println(it.next() + " is at index" + i); 
    }
}
```
Ce code va passer par la liste 1 liste à un seul élément à la fois et imprimer l'élément de texte, puis "est à l'index", puis il va imprimer l'index que l'itérateur trouvé. 🙂
- En fait, votre code est désactivé par un parce qu'il tente d'afficher l'index APRÈS l'appel à elle.next().
- Vous avez raison, merci! Très réponse tardive de ma part lol.
InformationsquelleAutor Ryan
0

Si vous avez déjà eu la réponse, pensé à ajouter quelques infos.

Comme vous l'avez mentionné Collections explicitement, vous ne pouvez pas utiliser listIterator pour obtenir l'index pour tous les types de collections.

Liste des interfaces - ArrayList, LinkedList, Vecteur et de la Pile.

A deux iterator() et listIterator()

Ensemble des interfaces - HashSet, LinkedHashSet, TreeSet et EnumSet.

A seulement iterator()

Carte interfaces - HashMap, LinkedHashMap, TreeMap et IdentityHashMap

N'a pas d'itérateurs, mais l'on peut parcourir à l'aide par le biais de la keySet() /values() ou entrySet() comme keySet() et entrySet() retourne Set et values() retourne Collection.

Donc de son mieux pour utiliser iterators() continue avec l'incrément de valeur pour obtenir l'indice actuel pour n'importe quel type de collection.

InformationsquelleAutor Vignesh Raja

Vous devez vous connecter pour publier un commentaire.