¿Hay alguna manera de acceder a un contador de iteraciones en el ciclo for-each de Java?

¿Hay alguna manera en el ciclo for-each de Java?

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

para saber con qué frecuencia el ciclo ya ha sido procesado?

Además de usar el viejo y conocido for(int i=0; i < boundary; i++)bucle, es la construcción

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

¿Cuál es la única manera de tener dicho contador disponible en un ciclo para cada uno?

No, pero puedes proporcionar tu propio contador.

La razón de esto es que el ciclo for-each internamente no tiene un contador; se basa en la interfaz Iterable , es decir, utiliza un Iteratorbucle a través de la "colección", que puede no ser una colección en absoluto, y de hecho puede ser algo que no se basa en ningún índice (como una lista vinculada).

Hay otra manera

Dado que usted escribe su propia Indexclase y un método estático que devuelve una Iterablesobre instancias de esta clase, puede

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

Donde la implementación de With.indexes algo así como

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 solución más fácil es simplemente ejecutar su propio contador así:

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

La razón de esto es porque no hay garantía real de que los elementos de una colección (que esa variante de foritera) incluso tengan un índice, o incluso tengan un orden definido (algunas colecciones pueden cambiar el orden cuando agrega o elimina elementos).

Vea, por ejemplo, el siguiente código:

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

Cuando ejecutas eso, puedes ver algo como:

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 que, con razón, el orden no se considera una característica destacada de un conjunto.

Hay otras formas de hacerlo sin un contador manual, pero es un buen trabajo para dudoso beneficio.

El uso de lambdas e interfaces funcionales en Java 8 hace posible la creación de nuevas abstracciones de bucle. Puedo recorrer una colección con el índice y el tamaño de la colección:

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

Qué salidas:

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

Lo que implementé como:

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

Las posibilidades son infinitas. Por ejemplo, creo una abstracción que usa una función especial solo para el primer elemento:

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

Que imprime una lista separada por comas correctamente:

one,two,three,four

Lo que implementé como:

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

Las bibliotecas comenzarán a aparecer para hacer este tipo de cosas, o puede rodar las suyas.

Java 8 introdujo el método Iterable#forEach()/ Map#forEach(), que es más eficiente para muchas implementaciones Collection/ en Mapcomparación con el ciclo "clásico" para cada bucle. Sin embargo, también en este caso no se proporciona un índice. El truco aquí es usar AtomicIntegerfuera de la expresión lambda. Nota: las variables utilizadas dentro de la expresión lambda deben ser efectivamente finales, es por eso que no podemos usar un ordinario int.

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

Me temo que esto no es posible con foreach. Pero puedo sugerirle unos simples bucles for de estilo antiguo :

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

Tenga en cuenta que la interfaz de Lista le da acceso a it.nextIndex().

(editar)

A su ejemplo cambiado:

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

Uno de los cambios que se Sunestá considerando Java7es proporcionar acceso al interior Iteratoren bucles foreach. la sintaxis será algo así (si se acepta):

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

Este es el azúcar sintáctico, pero aparentemente se hicieron muchas solicitudes para esta función. Pero hasta que se apruebe, tendrá que contar las iteraciones usted mismo o usar un ciclo regular para con un Iterator.

Solución idiomática:

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

esta es en realidad la solución que Google sugiere en la discusión de Guava sobre por qué no proporcionaron una CountingIterator.

Aunque hay muchas otras formas mencionadas para lograr lo mismo, compartiré mi camino con algunos usuarios insatisfechos. Estoy usando la característica Java 8 IntStream.

1. Matrices

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

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 necesita un contador en un ciclo para cada uno, debe contar usted mismo. No hay un mostrador incorporado hasta donde yo sé.

Hay una "variante" para la respuesta de pax ... ;-)

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

Para situaciones en las que solo necesito el índice ocasionalmente, como en una cláusula catch, a veces usaré 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 solución mejor y optimizada es hacer lo siguiente:

int i=0;

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

Donde Tipo puede ser cualquier tipo de datos y tipos es la variable en la que está solicitando un bucle.

Estoy un poco sorprendido de que nadie sugirió lo siguiente (admito que es un enfoque perezoso ...); Si stringArray es una lista de algún tipo, podría usar algo como stringArray.indexOf (S) para devolver un valor para el recuento actual.

Nota: esto supone que los elementos de la Lista son únicos, o que no importa si no son únicos (porque en ese caso devolverá el índice de la primera copia encontrada).

Hay situaciones en las que eso sería suficiente ...

Aquí hay un ejemplo de cómo hice esto. Esto obtiene el índice en cada ciclo. Espero que esto ayude.

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


    }
}