有没有办法在Java for-each循环中访问迭代计数器？


Is there a way to access an iteration-counter in Java's for-each loop?

Java的每个循环都有一种方法吗？

1
2
3
for(String s : stringArray) {
  doSomethingWith(s);
}

了解循环处理的频率？

除了使用旧的和众所周知的for(int i=0; i < boundary; i++)循环之外，结构

1
2
3
4
5
int i = 0;
for(String s : stringArray) {
  doSomethingWith(s);
  i++;
}

在for each循环中有这样一个计数器的唯一方法是什么？

相关讨论

没有，但是你可以提供你自己的柜台。

这样做的原因是for each循环内部没有计数器；它基于iterable接口，即它使用Iterator循环通过"collection"—它可能根本不是集合，实际上可能根本不是基于索引的集合(如链表)。

相关讨论

还有另一种方法。

假设您编写自己的Index类和一个静态方法，该方法在这个类的实例上返回Iterable，那么您可以

1
2
3
4
5
for (Index<String> each: With.index(stringArray)) {
    each.value;
    each.index;
    ...
}

其中With.index的实现类似于

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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++); }
                    ...
                }
            }
        }
    }
}
相关讨论

最简单的解决方案是运行自己的计数器，因此：

1
2
3
4
5
int i = 0;
for (String s : stringArray) {
    doSomethingWith(s, i);
    i++;
}

这是因为没有实际的保证集合中的项(for的变体迭代)甚至有索引，甚至有定义的顺序(某些集合在添加或删除元素时可能更改顺序)。

例如，请参见以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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");
  }
}

当你运行它的时候，你可以看到如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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中使用LAMBDAS和功能接口使得创建新的环路抽象成为可能。我可以循环使用索引和集合大小的集合：

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

输出：

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

我执行为：

1
2
3
4
5
6
7
8
9
10
11
   @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());
      }
   }

可能性是无限的。例如，我创建了一个抽象，它只对第一个元素使用一个特殊的函数：

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

正确打印逗号分隔列表：

1
one,two,three,four

我实施如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
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是不可能的。但是我可以建议你一个简单的旧样式的循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    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()的权限。

(编辑)

对于您更改的示例：

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

Java 8引入了EDCOX1×11 E/OCXX1×12的方法，对于每个EDCOX1，13，EDCX1，14个实现，与每个循环的"经典"相比，效率更高。但是，在这种情况下，也没有提供索引。这里的技巧是在lambda表达式之外使用AtomicInteger。注意：lambda表达式中使用的变量必须是有效的final，这就是我们不能使用普通int的原因。

1
2
3
4
5
final AtomicInteger indexHolder = new AtomicInteger();
map.forEach((k, v) -> {
    final int index = indexHolder.getAndIncrement();
    // use the index
});
相关讨论

Sun正在考虑对Java7进行的更改之一是提供对foreach循环中的内部Iterator的访问。语法如下(如果接受此语法)：

1
2
3
4
5
for (String str : list : it) {
  if (str.length() > 100) {
    it.remove();
  }
}

这是句法上的甜头，但显然有很多人对这个特性提出了要求。但是，在获得批准之前，您必须自己计算迭代次数，或者使用带有Iterator的常规for循环。

相关讨论

惯用解决方案：

1
2
3
4
5
6
7
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();
}

this is actually the solution that Google suggests in the Guava discussion on why they did not provide a CountingIterator.

尽管SOO还有很多其他的方式来实现这一点，但我会为一些不满意的用户分享我的方式。我正在使用Java 8的ItSt流特性。

1。数组

1
2
3
4
5
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。表

1
2
3
4
5
6
7
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循环中有一个计数器，你必须计算你自己。据我所知，没有内置计数器。

相关讨论

帕克斯的回答有一个"变种"…-)

1
2
3
4
int i = -1;
for(String s : stringArray) {
    doSomethingWith(s, ++i);
}
相关讨论

1
2
3
4
5
int i = 0;
for(String s : stringArray) {
    doSomethingWith(s,i);
    ++i;
}

方法有很多种，但方法是一种方法。

我发现使用带有递增索引的简单for循环是最有效、最可靠的解决方案，如本文所述：https://stackoverflow.com/a/3431543/2430549

对于偶尔只需要索引的情况，例如在catch子句中，有时会使用indexof。

1
2
3
4
5
6
7
8
for(String s : stringArray) {
  try {
    doSomethingWith(s);
  } catch (Exception e) {
    LOGGER.warn("Had some kind of problem with string" +
      stringArray.indexOf(s) +":" + s, e);
  }
}
相关讨论

下面是一个我如何做到这一点的例子。这将在for each循环中获取索引。希望这有帮助。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class CheckForEachLoop {

    public static void main(String[] args) {

        int[] myIntArray = new int[11];
        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
            }

        }
        System.out.println(s);


    }
}
相关讨论

我有点惊讶没有人提出以下建议(我承认这是一种懒惰的方法…)；如果StringArray是某种类型的列表，则可以使用StringArray.IndexOf之类的函数返回当前计数的值。

注意：这假定列表中的元素是唯一的，或者它们是否是非唯一的并不重要(因为在这种情况下，它将返回找到的第一个副本的索引)。

在某些情况下，这就足够了…

相关讨论