是否有一种方法可以在Java's for每个循环中访问迭代计数器?

在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循环中有这样一个计数器的唯一方法是什么?

285526 次浏览
小开

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

小开

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

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

这表明，顺序不被认为是一个集合的显著特征。

还有其他方法可以做到这一点——手动计数器，但这是一个相当多的工作，不确定的好处。

小开
最佳答案

没有，但你可以提供自己的柜台。

这样做的原因是for-each循环内部没有有计数器;它基于可迭代的接口，即它使用Iterator来循环遍历“集合”——这可能根本不是一个集合，实际上可能根本不是基于索引的东西(例如链表)。

小开

恐怕这在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();
}

注意，列表接口允许你访问it.nextIndex()。

(编辑)

到你改变的例子:

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

Sun正在为Java7考虑的一个变化是在foreach循环中提供对内部Iterator的访问。语法将是这样的(如果这是接受的):

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

这是语法上的甜食，但显然有很多人对这个功能提出了要求。但是在它被批准之前，你必须自己计算迭代次数，或者使用带有Iterator的常规for循环。

小开

还有另一种方法。

如果你写了自己的Index类和一个静态方法，该方法在这个类的实例上返回Iterable，你可以

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++); }
...
}
}
}
}
}
小开

pax的答案有一个“变体”…: -)

int i = -1;
for(String s : stringArray) {
doSomethingWith(s, ++i);
}
小开

我有点惊讶没有人建议以下(我承认这是一个懒惰的方法…); 如果stringArray是某种类型的List，您可以使用类似stringArray. indexof (S)的东西来返回当前计数的值

注意:这假设List的元素是唯一的，或者它们是否非唯一并不重要(因为在这种情况下，它将返回找到的第一个副本的索引)。

在某些情况下，这就足够了……

小开

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

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()方法，与“经典的”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
});
小开

对于偶尔需要索引的情况，比如在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);
}
}
小开

惯用的解决方案:

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

下面是我如何做到这一点的一个例子。这将获得每个循环的索引。希望这能有所帮助。

public class CheckForEachLoop {


public static void main(String[] args) {


String[] months = new String[] { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE", "JULY", "AUGUST",
"SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER" };
for (String s : months) {
if (s == months[2]) { // location where you can change
doSomethingWith(s); // however many times s and months
// doSomethingWith(s) will be completed and
// added together instead of counter
}


}
System.out.println(s);




}
}
小开

最佳和优化的解决方案是做以下事情:

int i=0;


for(Type t: types) {
......
i++;
}

其中Type可以是任何数据类型，types是应用于循环的变量。


提交答案