在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循环中使用计数器？
不可以，但您可以提供自己的计数器。
原因是for-each循环内部实际上没有计数器；它基于Iterable接口，即使用Iterator来遍历“集合”——这个“集合”可能根本不是一个基于索引的集合（例如链表），也可能完全不基于索引。
for(int idx=0, String s; s : stringArray; ++idx) doSomethingWith(s, idx);。 - Nicholas DiPiazzaEnumerable模块中有一个名为each_with_index的循环方法。请参阅apidock.com/ruby/Enumerable/each_with_index。 - saywhatnowfor (int i = 0; String s: stringArray; ++i)。 - izogfif还有一种方法。
假设您编写自己的 Index 类和一个静态方法，该方法返回一个可迭代对象，其中包含该类的实例，您可以
for (Index<String> each: With.index(stringArray)) {
each.value;
each.index;
...
}
With.index的实现类似于以下内容：
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++); }
...
}
}
}
}
}
With 对象通过增加指针在伊甸园上分配。不需要初始化，因为构造函数设置了所有字段。虚拟机保留了逃逸伊甸园的指针列表（据我所知），而我们的情况下该列表为空，因此在伊甸园上进行垃圾回收只需重置该指针即可。在2000年，分配对象曾经是一项昂贵的操作，但今天它是JVM中最便宜的操作之一。例如，对象池曾经是一个好主意，但今天却是一个非常糟糕的主意。 - akuhn最简单的解决方案是只需运行自己的计数器，如下所示:
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);
}
}
}
会出现一些库来完成这些事情，或者你可以自己开发。
Java 8引入了Iterable#forEach() / Map#forEach() 方法，在许多Collection / Map 实现中与“传统”的for-each循环相比更加高效。然而，即使在这种情况下也不提供索引。这里的诀窍是在lambda表达式外部使用AtomicInteger。注意：lambda表达式中使用的变量必须是有效final的，这就是为什么我们不能使用普通的int。
final AtomicInteger indexHolder = new AtomicInteger();
map.forEach((k, v) -> {
final int index = indexHolder.getAndIncrement();
// use the index
});
很遗憾，使用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接口允许您访问it.nextIndex()。
(编辑)
针对您更改的示例：
for(ListIterator<String> it =l.listIterator(); it.hasNext() ;)
{
int i = it.nextIndex();
doSomethingWith(it.next(), i);
}
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。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));
});
Sun 正在考虑为 Java7 提供访问 foreach 循环中内部 Iterator 的功能。如果此功能被接受，语法将类似于：
for (String str : list : it) {
if (str.length() > 100) {
it.remove();
}
}
这是语法糖，但显然有很多人要求这个功能。但在它获得批准之前，您将不得不自己计算迭代次数，或者使用带有Iterator的常规for循环。
对于只需要偶尔使用索引的情况，比如在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);
}
}
Type var = null; for (var : set) dosomething; if (var != null) then ...- Val