Existe uma maneira de acessar um contador de iteração no loop for-each do Java?

Existe uma maneira no loop for-each do Java

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

descobrir com que frequência o loop já foi processado?

Além de usar o antigo e bem conhecido for(int i=0; i < boundary; i++)loop, é a construção

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

a única maneira de ter esse contador disponível em um loop for-each?

Não, mas você pode fornecer seu próprio balcão.

A razão para isso é que o loop for-each internamente não possui um contador; baseia-se na interface Iterable , ou seja, usa um Iteratorloop para percorrer a "coleção" - que pode não ser uma coleção e pode ser algo que não é baseado em índices (como uma lista vinculada).

Existe outro caminho.

Dado que você escreve sua própria Indexclasse e um método estático que retorna Iterableinstâncias dessa classe, você pode

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

Onde a implementação de With.indexé algo 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++); }
                    ...
                }
            }
        }
    }
}

A solução mais fácil é executar o seu próprio contador assim:

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

O motivo disso é que não há garantia real de que os itens de uma coleção (sobre os quais a variante foritera) tenham um índice ou mesmo uma ordem definida (algumas coleções podem alterar a ordem quando você adiciona ou remove elementos).

Veja, por exemplo, o seguinte 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");
  }
}

Quando você executa isso, pode 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, com razão, a ordem não é considerada uma característica marcante de um conjunto.

Existem outras maneiras de fazer isso sem um contador manual, mas é um bom trabalho para benefício duvidoso.

O uso de lambdas e interfaces funcionais no Java 8 possibilita a criação de novas abstrações de loop. Eu posso repetir uma coleção com o índice e o tamanho da coleção:

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

Quais saídas:

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

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

As possibilidades são infinitas. Por exemplo, eu crio uma abstração que usa uma função especial apenas para o primeiro elemento:

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

Que imprime uma lista separada por vírgula corretamente:

one,two,three,four

Que eu implementei 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);
      }
   }
}

As bibliotecas começarão a aparecer para fazer esse tipo de coisa, ou você pode criar suas próprias.

O Java 8 introduziu o método Iterable#forEach()/ Map#forEach(), que é mais eficiente para muitas Collection/ Mapimplementações comparado ao "clássico" para cada loop. No entanto, também neste caso, um índice não é fornecido. O truque aqui é usar AtomicIntegerfora da expressão lambda. Nota: as variáveis ​​usadas na expressão lambda devem ser efetivamente finais, por isso não podemos usar um comum int.

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

Receio que isso não seja possível foreach. Mas posso sugerir-lhe um simples estilo antigo de loops :

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

Observe que, a interface da lista dá acesso a it.nextIndex().

(editar)

Para o seu exemplo alterado:

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

Uma das mudanças que Sunestá considerando Java7é fornecer acesso aos Iteratorloops foreach internos . a sintaxe será mais ou menos assim (se isso for aceito):

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

Isso é açúcar sintático, mas aparentemente muitos pedidos foram feitos para esse recurso. Mas até que seja aprovado, você precisará contar as iterações ou usar um loop for regular com um Iterator.

Solução Idiomatic:

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 é realmente a solução que o Google sugere na discussão do Guava sobre por que eles não forneceram a CountingIterator.

Embora existam muitas outras maneiras mencionadas para alcançar o mesmo, compartilharei o meu caminho com alguns usuários insatisfeitos. Estou usando o recurso Java 8 IntStream.

1. Matrizes

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

Se você precisar de um contador em um loop for-each, precisará contar a si mesmo. Não existe um balcão embutido, até onde eu saiba.

Existe uma "variante" para pax 'responder ... ;-)

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

Para situações em que eu só preciso do índice ocasionalmente, como em uma cláusula catch, algumas vezes usarei o 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);
  }
}

A solução melhor e otimizada é fazer o seguinte:

int i=0;

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

Onde Type pode ser qualquer tipo e tipo de dados é a variável na qual você está aplicando para um loop.

Estou um pouco surpreso que ninguém tenha sugerido o seguinte (admito que seja uma abordagem preguiçosa ...); Se stringArray for uma lista de algum tipo, você poderá usar algo como stringArray.indexOf (S) para retornar um valor para a contagem atual.

Nota: isso pressupõe que os elementos da Lista são únicos ou que não importa se não são únicos (porque nesse caso, ele retornará o índice da primeira cópia encontrada).

Existem situações em que isso seria suficiente ...

Aqui está um exemplo de como eu fiz isso. Isso obtém o índice no para cada loop. Espero que isto ajude.

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


    }
}