Есть ли способ получить доступ к счетчику итераций в цикле Java for-each?

есть другой способ.

учитывая, что вы пишете свой собственный Index класс и статический метод, который возвращает Iterable над экземплярами этого класса вы можете

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

внедрение With.index что-то вроде

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

самое простое решение is просто запустить свой собственный счетчик таким образом:

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

причина этого в том, что нет фактической гарантии, что элементы в коллекции (который этот вариант for перебирает) даже есть индекс, или даже определен порядок (некоторые коллекции могут изменить порядок при добавлении или удалении элементов).

см., например, следующий код:

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

при запуске, что, вы можете увидеть что-то вроде:

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

указывая, что, правильно, порядок не считается заметной особенностью набора.

есть и другие способы сделать это без Ручной счетчик, но это справедливая работа для сомнительной выгоды.

используя лямбда и функциональные интерфейсы на Java 8 делает возможным создание новых абстракций цикла. Я могу перебирать коллекцию с индексом и размером коллекции:

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

выходы:

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

, который я реализовал так:

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

возможности безграничны. Например, я создаю абстракцию, которая использует специальную функцию только для первого элемент:

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

, который печатает список, разделенный запятыми, правильно:

one,two,three,four

, который я реализовал так:

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

библиотеки начнут появляться, чтобы делать такие вещи, или вы можете свернуть свой собственный.

боюсь, это невозможно с foreach. Но я могу предложить вам простой старый стиль для-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();
    }

заметил, что список интерфейс дает вам доступ к it.nextIndex().

(редактировать)

к вашему измененному примеру:

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

Java 8 представила Iterable#forEach() / Map#forEach() метод, который более эффективен для многих Collection / Map реализации по сравнению с "классическим" для каждого цикла. Однако и в этом случае индекс не предусмотрено. Фокус здесь в том, чтобы использовать AtomicInteger вне лямбда-выражения. Примечание: переменные, используемые в лямбда-выражении, должны быть фактически окончательными, поэтому мы не можем использовать обычный int.

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

одно из изменений Sun рассматривает для Java7 должен обеспечить доступ к внутреннему Iterator в foreach петли. синтаксис будет примерно таким (если это принято):

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

это синтаксический сахар, но, по-видимому, было сделано много запросов для этой функции. Но пока он не будет одобрен, вам придется рассчитывать итерации самостоятельно или использовать регулярный цикл for с Iterator.

Идиоматическое Решение:

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

это на самом деле решение, что Google предлагает в гуавы обсуждения почему они не дают CountingIterator.

Если вам нужен счетчик в цикле for-each, вам нужно подсчитать себя. Насколько мне известно, встроенного счетчика нет.

существует" вариант " для ответа pax... ;-)

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

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

есть много способов, но метод является одним из способов

Я обнаружил, что использование простого цикла for с инкрементным индексом было наиболее эффективным и надежным решением, как указано здесь:https://stackoverflow.com/a/3431543/2430549

для ситуаций, когда мне нужен индекс только иногда, как в предложении catch, я иногда буду использовать 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);
  }
}

Я немного удивлен, что никто не предложил следующее (Я признаю, что это ленивый подход...); Если stringArray-это какой-то список, вы можете использовать что-то вроде stringArray.indexOf(s) для возврата значения текущего счета.

Примечание: это предполагает, что элементы списка уникальны или что не имеет значения, являются ли они не уникальными (потому что в этом случае он вернет индекс первой найденной копии).

есть ситуации, в которых это будет достаточный...