C'è un modo per accedere a un contatore di iterazioni nel ciclo for-each di Java?

C'è un modo nel ciclo for-each di Java

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

per scoprire con quale frequenza il loop è già stato elaborato?

Oltre a usare il vecchio e noto for(int i=0; i < boundary; i++)- loop, è il costrutto

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

l'unico modo per avere un tale contatore disponibile in un ciclo per ogni?

No, ma puoi fornire il tuo contatore.

La ragione di ciò è che il ciclo for-each internamente non ha un contatore; si basa sull'interfaccia Iterable , ovvero utilizza un Iteratorciclo per la "raccolta", che potrebbe non essere affatto una raccolta e potrebbe in effetti essere qualcosa che non si basa affatto su indici (come un elenco collegato).

C'è un altro modo.

Dato che scrivi la tua Indexclasse e un metodo statico che restituisce un Iterableover di istanze di questa classe, puoi farlo

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

Dove l'implementazione di With.indexè qualcosa di simile

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 soluzione più semplice è semplicemente eseguire il proprio contatore in questo modo:

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

Il motivo è dovuto al fatto che non esiste alcuna garanzia concreta che gli articoli in una raccolta (su cui quella variante è forripetuta) abbiano persino un indice o addirittura un ordine definito (alcune raccolte possono cambiare l'ordine quando si aggiungono o rimuovono elementi).

Vedi ad esempio il seguente codice:

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");
  }
}

Quando lo esegui, puoi vedere qualcosa del tipo:

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

indicando che, giustamente, l'ordine non è considerato una caratteristica saliente di un insieme.

Ci sono altri modi per farlo senza un contatore manuale, ma è un bel po 'di lavoro a beneficio discutibile.

L'uso di lambda e interfacce funzionali in Java 8 rende possibile la creazione di nuove astrazioni di loop. Posso passare in rassegna una raccolta con l'indice e le dimensioni della raccolta:

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

Quali uscite:

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

Che ho implementato come:

   @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());
      }
   }

Le possibilità sono infinite. Ad esempio, creo un'astrazione che utilizza una funzione speciale solo per il primo elemento:

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

Che stampa correttamente un elenco separato da virgole:

one,two,three,four

Che ho implementato come:

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);
      }
   }
}

Le biblioteche inizieranno a comparire per fare questo genere di cose, oppure puoi farlo tu stesso.

Java 8 ha introdotto il metodo Iterable#forEach()/ Map#forEach(), che è più efficiente per molte Collection/ Mapimplementazioni rispetto al "classico" per ogni ciclo. Tuttavia, anche in questo caso non viene fornito un indice. Il trucco qui è usare AtomicIntegeral di fuori dell'espressione lambda. Nota: le variabili utilizzate nell'espressione lambda devono essere effettivamente finali, ecco perché non possiamo usare un normale int.

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

Temo che non sia possibile foreach. Ma posso suggerirti un semplice for-loop vecchio stile :

    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();
    }

Si noti che, l' interfaccia Elenco consente di accedere a it.nextIndex().

(modificare)

Al tuo esempio modificato:

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

Uno dei cambiamenti che Sunsta prendendo in considerazione Java7è quello di fornire l'accesso all'interno dei Iteratorcircuiti foreach. la sintassi sarà simile a questa (se questa è accettata):

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

Questo è zucchero sintattico, ma a quanto pare sono state fatte molte richieste per questa funzione. Ma fino a quando non verrà approvato, dovrai contare tu stesso le iterazioni o utilizzare un ciclo for regolare con un Iterator.

Soluzione idiomatica:

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();
}

questa è in realtà la soluzione che Google suggerisce nella discussione di Guava sul perché non hanno fornito un CountingIterator.

Sebbene ci siano così tanti altri modi per raggiungere lo stesso obiettivo, condividerò la mia strada per alcuni utenti insoddisfatti. Sto usando la funzione Java 8 IntStream.

1. Matrici

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. Elenco

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));
});

Se hai bisogno di un contatore in un ciclo per ogni devi contare te stesso. Non esiste un contatore incorporato per quanto ne so.

C'è una "variante" alla risposta di pax ... ;-)

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

Per situazioni in cui ho solo bisogno dell'indice di tanto in tanto, come in una clausola di cattura, a volte userò 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 soluzione migliore e ottimizzata è fare quanto segue:

int i=0;

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

Dove Tipo può essere qualsiasi tipo di dati e tipi è la variabile a cui si sta facendo domanda per un ciclo.

Sono un po 'sorpreso che nessuno abbia suggerito quanto segue (ammetto che è un approccio pigro ...); Se stringArray è un elenco di qualche tipo, è possibile utilizzare qualcosa come stringArray.indexOf (S) per restituire un valore per il conteggio corrente.

Nota: ciò presuppone che gli elementi dell'elenco siano univoci o che non importa se non sono univoci (perché in tal caso restituirà l'indice della prima copia trovata).

Ci sono situazioni in cui ciò sarebbe sufficiente ...

Ecco un esempio di come ho fatto questo. Questo ottiene l'indice in corrispondenza di ciascun ciclo. Spero che questo ti aiuti.

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); 


    }
}