Existe-t-il un moyen d'accéder à un compteur d'itérations dans la boucle for-each de Java?

Existe-t-il un moyen dans la boucle for-each de Java

for(String s : stringArray) {
  doSomethingWith(s);
}

pour savoir à quelle fréquence la boucle a déjà été traitée?

Outre l'utilisation de l'ancienne et bien connue for(int i=0; i < boundary; i++)boucle, la construction

int i = 0;
for(String s : stringArray) {
  doSomethingWith(s);
  i++;
}

la seule façon d'avoir un tel compteur disponible dans une boucle pour chaque?

Non, mais vous pouvez fournir votre propre comptoir.

La raison en est que le pour-chaque boucle interne ne pas avoir un compteur; il est basé sur l' interface Iterable , c'est-à-dire qu'il utilise un Iteratorpour parcourir la "collection" - qui peut ne pas être du tout une collection, et peut en fait ne pas être du tout basé sur des index (comme une liste chaînée).

Il y a une autre manière.

Étant donné que vous écrivez votre propre Indexclasse et une méthode statique qui renvoie une Iterablesurinstance de cette classe, vous pouvez

for (Index<String> each: With.index(stringArray)) {
    each.value;
    each.index;
    ...
}

Où la mise en œuvre de With.indexquelque chose comme

class With {
    public static <T> Iterable<Index<T>> index(final T[] array) {
        return new Iterable<Index<T>>() {
            public Iterator<Index<T>> iterator() {
                return new Iterator<Index<T>>() {
                    index = 0;
                    public boolean hasNext() { return index < array.size }
                    public Index<T> next() { return new Index(array[index], index++); }
                    ...
                }
            }
        }
    }
}

La solution la plus simple consiste à exécuter simplement votre propre compteur ainsi:

int i = 0;
for (String s : stringArray) {
    doSomethingWith(s, i);
    i++;
}

La raison en est qu'il n'y a aucune garantie réelle que les éléments d'une collection (que cette variante d' foritère) ont même un index, ou même un ordre défini (certaines collections peuvent changer l'ordre lorsque vous ajoutez ou supprimez des éléments).

Voir par exemple le code suivant:

import java.util.*;

public class TestApp {
  public static void AddAndDump(AbstractSet<String> set, String str) {
    System.out.println("Adding [" + str + "]");
    set.add(str);
    int i = 0;
    for(String s : set) {
        System.out.println("   " + i + ": " + s);
        i++;
    }
  }

  public static void main(String[] args) {
    AbstractSet<String> coll = new HashSet<String>();
    AddAndDump(coll, "Hello");
    AddAndDump(coll, "My");
    AddAndDump(coll, "Name");
    AddAndDump(coll, "Is");
    AddAndDump(coll, "Pax");
  }
}

Lorsque vous exécutez cela, vous pouvez voir quelque chose comme:

Adding [Hello]
   0: Hello
Adding [My]
   0: Hello
   1: My
Adding [Name]
   0: Hello
   1: My
   2: Name
Adding [Is]
   0: Hello
   1: Is
   2: My
   3: Name
Adding [Pax]
   0: Hello
   1: Pax
   2: Is
   3: My
   4: Name

indiquant que, à juste titre, l'ordre n'est pas considéré comme une caractéristique saillante d'un ensemble.

Il existe d'autres façons de le faire sans compteur manuel, mais c'est un peu de travail pour des avantages douteux.

L'utilisation de lambdas et d' interfaces fonctionnelles dans Java 8 permet de créer de nouvelles abstractions de boucle. Je peux parcourir une collection avec l'index et la taille de la collection:

List<String> strings = Arrays.asList("one", "two","three","four");
forEach(strings, (x, i, n) -> System.out.println("" + (i+1) + "/"+n+": " + x));

Quelles sorties:

1/4: one
2/4: two
3/4: three
4/4: four

Que j'ai implémenté comme:

   @FunctionalInterface
   public interface LoopWithIndexAndSizeConsumer<T> {
       void accept(T t, int i, int n);
   }
   public static <T> void forEach(Collection<T> collection,
                                  LoopWithIndexAndSizeConsumer<T> consumer) {
      int index = 0;
      for (T object : collection){
         consumer.accept(object, index++, collection.size());
      }
   }

Les possibilités sont infinies. Par exemple, je crée une abstraction qui utilise une fonction spéciale juste pour le premier élément:

forEachHeadTail(strings, 
                (head) -> System.out.print(head), 
                (tail) -> System.out.print(","+tail));

Qui imprime correctement une liste séparée par des virgules:

one,two,three,four

Que j'ai implémenté comme:

public static <T> void forEachHeadTail(Collection<T> collection, 
                                       Consumer<T> headFunc, 
                                       Consumer<T> tailFunc) {
   int index = 0;
   for (T object : collection){
      if (index++ == 0){
         headFunc.accept(object);
      }
      else{
         tailFunc.accept(object);
      }
   }
}

Les bibliothèques commenceront à apparaître pour faire ce genre de choses, ou vous pouvez rouler les vôtres.

Java 8 a introduit la méthode Iterable#forEach()/ Map#forEach(), qui est plus efficace pour de nombreuses implémentations Collection/ Mappar rapport à la boucle "classique" pour chaque boucle. Cependant, dans ce cas également, aucun index n'est fourni. L'astuce consiste à utiliser en AtomicIntegerdehors de l'expression lambda. Remarque: les variables utilisées dans l'expression lambda doivent être effectivement finales, c'est pourquoi nous ne pouvons pas utiliser d'ordinaire int.

final AtomicInteger indexHolder = new AtomicInteger();
map.forEach((k, v) -> {
    final int index = indexHolder.getAndIncrement();
    // use the index
});

Je crains que ce ne soit pas possible avec foreach. Mais je peux vous suggérer une simple boucle for-old style :

    List<String> l = new ArrayList<String>();

    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");

    // the array
    String[] array = new String[l.size()];

    for(ListIterator<String> it =l.listIterator(); it.hasNext() ;)
    {
        array[it.nextIndex()] = it.next();
    }

Notez que l' interface List vous donne accès à it.nextIndex().

(Éditer)

À votre exemple changé:

    for(ListIterator<String> it =l.listIterator(); it.hasNext() ;)
    {
        int i = it.nextIndex();
        doSomethingWith(it.next(), i);
    }

L'un des changements Sunenvisagés Java7est de fournir un accès aux Iteratorboucles internes dans foreach. la syntaxe sera quelque chose comme ça (si cela est accepté):

for (String str : list : it) {
  if (str.length() > 100) {
    it.remove();
  }
}

C'est du sucre syntaxique, mais apparemment beaucoup de demandes ont été faites pour cette fonctionnalité. Mais jusqu'à ce qu'il soit approuvé, vous devrez compter les itérations vous-même, ou utiliser une boucle for régulière avec un Iterator.

Solution idiomatique:

final Set<Double> doubles; // boilerplate
final Iterator<Double> iterator = doubles.iterator();
for (int ordinal = 0; iterator.hasNext(); ordinal++)
{
    System.out.printf("%d:%f",ordinal,iterator.next());
    System.out.println();
}

c'est en fait la solution que Google suggère dans la discussion sur Guava pour expliquer pourquoi ils n'ont pas fourni de CountingIterator.

Bien qu'il y ait tellement d'autres moyens mentionnés pour y parvenir, je partagerai mon chemin pour certains utilisateurs insatisfaits. J'utilise la fonction Java 8 IntStream.

1. Tableaux

Object[] obj = {1,2,3,4,5,6,7};
IntStream.range(0, obj.length).forEach(index-> {
    System.out.println("index: " + index);
    System.out.println("value: " + obj[index]);
});

2. Liste

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

IntStream.range(0, strings.size()).forEach(index-> {
    System.out.println("index: " + index);
    System.out.println("value: " + strings.get(index));
});

Si vous avez besoin d'un compteur dans une boucle pour chaque, vous devez vous compter. Il n'y a pas de compteur intégré pour autant que je sache.

Il y a une "variante" à la réponse de pax ... ;-)

int i = -1;
for(String s : stringArray) {
    doSomethingWith(s, ++i);
}

Pour les situations où je n'ai besoin que de l'index de temps en temps, comme dans une clause catch, j'utilise parfois indexOf.

for(String s : stringArray) {
  try {
    doSomethingWith(s);
  } catch (Exception e) {
    LOGGER.warn("Had some kind of problem with string " +
      stringArray.indexOf(s) + ": " + s, e);
  }
}

La meilleure solution optimisée consiste à effectuer les opérations suivantes:

int i=0;

for(Type t: types) {
  ......
  i++;
}

Où Type peut être n'importe quel type de données et types est la variable sur laquelle vous appliquez pour une boucle.

Je suis un peu surpris que personne n'ait suggéré ce qui suit (j'avoue que c'est une approche paresseuse ...); Si stringArray est une liste quelconque, vous pouvez utiliser quelque chose comme stringArray.indexOf (S) pour renvoyer une valeur pour le nombre actuel.

Remarque: cela suppose que les éléments de la liste sont uniques ou peu importe s'ils ne le sont pas (car dans ce cas, il renverra l'index de la première copie trouvée).

Il y a des situations où cela serait suffisant ...

Voici un exemple de la façon dont j'ai fait cela. Cela obtient l'index au niveau de chaque boucle. J'espère que cela t'aides.

public class CheckForEachLoop {

    public static void main(String[] args) {

        String[] months = new String[] { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE", "JULY", "AUGUST",
                "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER" };
        for (String s : months) {
            if (s == months[2]) { // location where you can change
              doSomethingWith(s); // however many times s and months
                                  // doSomethingWith(s) will be completed and 
                                  // added together instead of counter
            }

        }
        System.out.println(s); 


    }
}