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

在Java的for-each循环中是否有一种方法

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循环中使用这种计数器的唯一方法是什么？

1> Michael Borg..：

---

不,但你可以提供自己的柜台.

这样做的原因是,for-each循环在内部不具有一个计数器; 它基于Iterable接口,即它使用Iterator循环遍历"集合" - 它可能根本不是集合,实际上可能根本不是基于索引(例如链表).

---

答案应该以"不,但你可以提供自己的柜台"开头.

---

Ruby有一个构造,Java也应该得到它...`for(int idx = 0,String s; s:stringArray; ++ idx)doSomethingWith(s,idx);`

---

"这样做的原因是for-each循环内部没有计数器".应该被解读为"Java开发人员不关心让程序员在`for`循环中指定初始值的索引变量",类似于`for(int i = 0; String s:stringArray; ++ i)`

2> akuhn..：

---

还有另一种方式.

鉴于您编写自己的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++); }
                    ...
                }
            }
        }
    }
}

---

干净的想法.如果没有为Index类的短期对象创建,我会投赞成票.

---

如果你担心像这样的短命物体的性能,你做错了.性能应该是最后要担心的事情......可读性第一.这实际上是一个非常好的结构.

---

我要说的是,我真的不明白是什么时候需要辩论索引实例可以创建一次并重新使用/更新,只是为了鼓舞争论并让每个人都开心.但是,在我的测量中,每次创建一个新Index()的版本在我的机器上执行速度的两倍以上,大约相当于运行相同迭代的本机迭代器.

---

@ mR_fr0g不用担心,我对此进行了基准测试并且创建所有这些对象并不比每次迭代重用相同的对象慢.原因是所有这些对象仅在eden空间中分配,并且永远不会长到足以到达堆.因此,分配它们与分配局部变量一样快.

3> paxdiablo..：

---

最简单的解决方案是运行自己的计数器:

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

表明,正确地说,顺序不被视为集合的显着特征.

还有其他方法可以在没有手动计数器的情况下完成,但这对于可疑的益处来说是一项相当大的工作.

---

即使使用List和Iterable接口,这似乎仍然是最清晰的解决方案.

4> James Scrive..：

---

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

图书馆将开始弹出来做这些事情,或者你可以自己动手.

---

不是对帖子的批评(这是我现在用的"很酷的方式"),但我很难看到这比简单的旧学校循环更容易/更好:for(int i = 0; i < list.size(); i ++){}即使是奶奶也能理解这一点,并且在没有lambda使用的语法和不常见字符的情况下输入可能更容易.不要误解我的意思,我喜欢将lambdas用于某些事情(回调/事件处理程序类型的模式),但我无法理解在这种情况下的用法.伟大的工具,但使用它_all time_,我只是做不到.

5> rmuller..：

---

Java 8引入了Iterable#forEach()/ Map#forEach()method,与"经典"for-each循环相比,它对许多Collection/ Map实现更有效.但是,在这种情况下也不提供索引.这里的技巧是AtomicInteger在lambda表达式之外使用.注意:lambda表达式中使用的变量必须是有效的,这就是为什么我们不能使用普通的int.

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

6> bruno conde..：

---

我担心这是不可能的foreach.但我可以建议你一个简单的旧式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);
    }

7> Yuval..：

---

其中一个变化Sun是考虑Java7提供对Iteratorforeach循环内部的访问.语法将是这样的(如果这是接受的):

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

这是语法糖,但显然对此功能提出了很多要求.但是在批准之前,你必须自己计算迭代次数,或者使用常规for循环Iterator.

---

我们现在知道,它不被接受.

8> 小智..：

---

惯用解决方案:

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.