Есть ли способ получить доступ к счетчику итераций в цикле Java for-each?
есть ли способ в Java для каждого цикла
for(String s : stringArray) {
doSomethingWith(s);
}
чтобы выяснить, как часто цикл уже был обработан?
Помимо использования старого и хорошо известного for(int i=0; i < boundary; i++)
- loop, является конструктом
int i = 0;
for(String s : stringArray) {
doSomethingWith(s);
i++;
}
единственный способ иметь такой счетчик, доступный в цикле for-each?
14 ответов
нет, но вы можете предоставить свой собственный счетчик.
причина этого в том, что цикл 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++); }
...
}
}
}
}
}
самое простое решение 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) для возврата значения текущего счета.
Примечание: это предполагает, что элементы списка уникальны или что не имеет значения, являются ли они не уникальными (потому что в этом случае он вернет индекс первой найденной копии).
есть ситуации, в которых это будет достаточный...