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

时间：2009-01-25 11:05:37

标签： java loops for-loop foreach

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

17 个答案:

答案 0 :(得分：179)

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

原因是for-each循环内部没有拥有计数器;它基于Iterable接口，即它使用Iterator循环遍历“集合” - 它可能根本不是集合，实际上可能根本不是基于索引的东西（例如链表）。

答案 1 :(得分：59)

还有另一种方式。

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

答案 2 :(得分：41)

最简单的解决方案 只能运行自己的计数器：

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

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

还有其他方法可以做到没有一个手动计数器，但这对于可疑的利益来说是相当有用的工作。

答案 3 :(得分：23)

在 Java 8 中使用 lambdas 和功能接口可以创建新的循环抽象。我可以使用索引和集合大小循环遍历集合：

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

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

答案 4 :(得分：16)

我担心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);
    }

答案 5 :(得分：15)

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

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

答案 6 :(得分：9)

Sun正在考虑的其中一项更改是提供对foreach循环中内部Java7的访问权限。语法将是这样的（如果这被接受）：

Iterator

这是语法糖，但显然对此功能提出了很多要求。但是在批准之前，您必须自己计算迭代次数，或者使用for (String str : list : it) { if (str.length() > 100) { it.remove(); } } 的常规for循环。

答案 7 :(得分：5)

惯用解决方案：

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

这实际上是Google在Guava discussion中建议他们没有提供CountingIterator的解决方案。

答案 8 :(得分：2)

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

答案 9 :(得分：2)

尽管提到了许多其他方法可以达到相同的目的，但我还是会与一些不满意的用户分享我的方法。我正在使用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));
});

答案 10 :(得分：1)

pax'回答......; - ）

有一个“变体” 
int i = -1;
for(String s : stringArray) {
    doSomethingWith(s, ++i);
}

答案 11 :(得分：1)

int i = 0;
for(String s : stringArray) {
    doSomethingWith(s,i);
    ++i;
}

有很多方法，但方法是其中一种方式

答案 12 :(得分：0)

我发现使用带有递增索引的简单for循环是最有效，最可靠的解决方案，如下所示：https://stackoverflow.com/a/3431543/2430549

答案 13 :(得分：0)

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

答案 14 :(得分：-1)

这是我如何执行此操作的示例。这将获得每个循环的索引。希望这可以帮助。 

public class CheckForEachLoop {

    public static void main(String[] args) {

        int[] myIntArray = new int[11];
        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
            }

        }
        System.out.println(s); 


    }
}

答案 15 :(得分：-1)

最佳和优化的解决方案是执行以下操作：

int i=0;

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

“类型”可以是任何数据类型，而“类型”是要为其应用循环的变量。

答案 16 :(得分：-4)

我有点惊讶没有人提出以下建议（我承认这是一种懒惰的做法......）; 如果stringArray是某种类型的List，你可以使用stringArray.indexOf（S）之类的东西来返回当前计数的值。

注意：这假定List的元素是唯一的，或者它们是非唯一的无关紧要（因为在这种情况下它将返回找到的第一个副本的索引）。

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

相关问题
最新问题