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

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

虽然有很多其他的方法可以达到同样的效果，但我还是将我的方法分享给一些不满意的用户。我正在使用Java 8 IntStream特性。

1. 数组

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. 列表

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

惯用的解决方案:

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的讨论中提出的解决方案。

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

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

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

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中使用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);
      }
   }
}

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