有没有办法在Java for-each循环中访问迭代计数器？
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循环遍历“集合” - 它可能根本不是集合，实际上可能根本不是基于索引(例如链表)。
还有另一种方式。
鉴于您编写自己的With.index类和一个静态方法，该方法通过此类的实例返回Iterable，您可以
for (Index each: With.index(stringArray)) {
each.value;
each.index;
...
}哪里执行With.index就好
class With {
public static Iterable> index(final T[] array) {
return new Iterable>() {
public Iterator> iterator() {
return new Iterator>() {
index = 0;
public boolean hasNext() { return index < array.size }
public Index 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 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 coll = new HashSet();
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中使用lambdas和功能接口可以创建新的循环抽象。 我可以使用索引和集合大小遍历集合：
List 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 {
void accept(T t, int i, int n);
}
public static void forEach(Collection collection,
LoopWithIndexAndSizeConsumer 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 void forEachHeadTail(Collection collection,
Consumer headFunc,
Consumer tailFunc) {
int index = 0;
for (T object : collection){
if (index++ == 0){
headFunc.accept(object);
}
else{
tailFunc.accept(object);
}
}
}图书馆将开始弹出来做这些事情，或者你可以自己动手。
我担心这是不可能的it.nextIndex().但我可以建议你一个简单的旧式for循环：
List l = new ArrayList();
l.add("a");
l.add("b");
l.add("c");
l.add("d");
// the array
String[] array = new String[l.size()];
for(ListIterator it =l.listIterator(); it.hasNext() ;)
{
array[it.nextIndex()] = it.next();
}请注意，List接口允许您访问it.nextIndex()。
对于你改变的例子：
for(ListIterator it =l.listIterator(); it.hasNext() ;)
{
int i = it.nextIndex();
doSomethingWith(it.next(), i);
}Java 8引入了Iterable#forEach()/Map#forEach()方法，与“经典”for-each循环相比，该方法对于许多实现更有效。 但是，在这种情况下也不提供索引。 这里的技巧是在lambda表达式之外使用AtomicInteger。 注意：lambda表达式中使用的变量必须是有效的，这就是为什么我们不能使用普通的int。
final AtomicInteger indexHolder = new AtomicInteger();
map.forEach((k, v) -> {
final int index = indexHolder.getAndIncrement();
// use the index
});其中一个变化Iterator正在考虑为Java7提供访问内部循环中的内部Iterator。 语法将是这样的(如果这是接受的)：
for (String str : list : it) {
if (str.length() > 100) {
it.remove();
}
}这是语法糖，但显然对此功能提出了很多要求。 但是在它被批准之前，你必须自己计算迭代次数，或者使用Iterator的常规for循环。
惯用解决方案：
final Set doubles; // boilerplate
final Iterator iterator = doubles.iterator();
for (int ordinal = 0; iterator.hasNext(); ordinal++)
{
System.out.printf("%d:%f",ordinal,iterator.next());
System.out.println();
}这实际上是谷歌在番石榴讨论中建议他们为什么不提供CountingIterator的解决方案。
如果你需要一个for-each循环中的计数器，你必须自己计算。 据我所知，没有内置的柜台。
pax'答案有一个“变种”...... ;-)
int i = -1;
for(String s : stringArray) {
doSomethingWith(s, ++i);
}
Jörg answered 2019-03-05T01:34:04Z
1 votes
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是某种类型的List，您可以使用stringArray.indexOf(S)之类的东西来返回当前计数的值。
注意：这假定List的元素是唯一的，或者它们是非唯一的无关紧要(因为在这种情况下它将返回找到的第一个副本的索引)。
在某些情况下，这就足够了......
