Есть ли способ получить доступ к счетчику итераций в цикле Java для каждого?

Есть ли способ в цикле Java для каждого

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

узнать, как часто цикл уже обрабатывается?

Помимо использования старого и известного for(int i=0; i < boundary; i++)цикла - это конструкция

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

единственный способ иметь такой счетчик в цикле for-each?

Нет, но вы можете предоставить свой счетчик.

Причина этого заключается в том, что цикл for-each внутри не имеет счетчика; он основан на интерфейсе Iterable , то есть он использует Iteratorцикл для «коллекции», которая может вообще не быть коллекцией, а может фактически быть чем-то совсем не основанным на индексах (таких как связанный список).

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

Учитывая, что вы пишете свой собственный 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++); }
                    ...
                }
            }
        }
    }
}

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

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

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

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

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

Боюсь, это невозможно foreach. Но я могу предложить вам простой цикл в старом стиле :

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

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

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

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

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

Одним из рассматриваемых изменений 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.

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

1. Массивы

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. Список

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

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

Есть вариант ответа pax ... ;-)

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

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

Лучшее и оптимизированное решение - сделать следующее:

int i=0;

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

Где Тип может быть любым типом данных, а тип - это переменная, к которой вы применяете цикл.

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

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

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

Вот пример того, как я это сделал. Это получает индекс для каждого цикла. Надеюсь это поможет.

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


    }
}