惯用的解决方案:

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

这实际上是谷歌在关于为什么他们不提供CountingIterator的讨论中提出的解决方案。

惯用的解决方案:

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

这实际上是谷歌在关于为什么他们不提供CountingIterator的讨论中提出的解决方案。

如果你在for-each循环中需要一个计数器，你就必须数自己。据我所知，没有内置的计数器。

我通常使用数组来解决这个问题

List<String> list = new ArrayList<String>();

final int[] counter = new int[1];

list.foreach( item -> {
    list.get(counter[0])   // code here that can use counter[0] for counter value
    counter[0]++;          // increment the counter
}

恐怕foreach不行。但我可以给你一个简单的老式for循环:

    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接口允许您访问它。nextindex()。

(编辑)

到你改变的例子:

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

在Java 8中使用lambda和函数接口使得创建新的循环抽象成为可能。我可以通过索引和集合大小来循环一个集合:

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

库将开始弹出来做这些事情，或者你可以自己编写。