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

Posted

技术标签:

【中文标题】有没有办法在 Java for-each 循环中访问迭代计数器?【英文标题】:Is there a way to access an iteration-counter in Java's for-each loop? 【发布时间】:2010-10-03 09:58:33 【问题描述】:

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

【问题讨论】:

另外一个遗憾是不能在循环外使用循环变量,Type var = null; for (var : set) dosomething; if (var != null) then ... @Val 除非引用是最终有效的。有关如何使用此功能,请参阅我的答案 【参考方案1】:

没有,但您可以提供自己的柜台。

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

【讨论】:

Ruby 对此有一个构造,Java 也应该得到它...for(int idx=0, String s; s : stringArray; ++idx) doSomethingWith(s, idx); 仅供参考 @NicholasDiPiazza 在 Ruby 中有一个 each_with_index 循环方法用于 Enumerable。请参阅 apidock.com/ruby/Enumerable/each_with_index @saywhatnow 是的,这就是我的意思抱歉 - 不知道我在发表上一条评论时抽的是什么烟 “原因是for-each循环内部没有计数器”。应该读作“Java 开发人员不关心让程序员for 循环内指定具有初始值的索引变量”,类似于 for (int i = 0; String s: stringArray; ++i) 为什么我们不能为任何可迭代的东西维护一个索引/计数器? LinkedList 不是基于索引的,但我们仍然有 ListIterator,它在对其进行迭代时在内部维护一个计数器。如果我们正在迭代意味着我们有 n 个项目的东西,无论是任何格式/DS。不是吗?任何无法维护索引的示例都会有所帮助。谢谢。【参考方案2】:

还有另一种方法。

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

【讨论】:

好主意。如果不是因为 Index 类的短暂对象创建,我会投票赞成。 @mR_fr0g 别担心,我对此进行了基准测试,创建所有这些对象并不比每次迭代重用同一个对象慢。原因是所有这些对象都只分配在伊甸园空间中,并且永远不会有足够长的时间到达堆。因此分配它们的速度与例如分配局部变量。 @akuhn 等等。 Eden 空间并不意味着不需要 GC。恰恰相反,您需要调用构造函数,使用 GC 更快地扫描并完成。这不仅会加载 CPU,还会一直使缓存无效。对于局部变量,这样的事情是不必要的。为什么说这是“一样的”? 如果您担心像这样的短期对象的性能,那么您做错了。性能应该是最不应该担心的事情……可读性是第一位的。这实际上是一个很好的结构。 我想说我真的不明白何时可以创建一次索引实例并重用/更新,只是为了争论并让每个人都开心。然而,在我的测量中,每次创建一个新 Index() 的版本在我的机器上的执行速度是我的两倍多,大约等于运行相同迭代的本机迭代器。【参考方案3】:

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

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

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

还有其他方法可以做到这一点没有手动计数器,但它的工作量相当可观。

【讨论】:

这似乎仍然是最清晰的解决方案,即使使用 List 和 Iterable 接口。【参考方案4】:

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

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

【讨论】:

不是对这篇文章的批评(我猜现在这是“很酷的做法”),但我很难看出这比简单的老式 for 循环更容易/更好: (int i = 0; i 一直在使用它,我就是做不到。 我想,可以避免对列表本身的非一索引上溢/下溢。但是上面发布了一个选项: int i = 0; for (String s : stringArray) doSomethingWith(s, i);我++; 【参考方案5】:

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

【讨论】:

【参考方案6】:

恐怕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);
    

【讨论】:

【参考方案7】:

惯用的解决方案:

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】:

Sun 正在考虑对 Java7 进行的更改之一是在 foreach 循环中提供对内部 Iterator 的访问。语法将是这样的(如果这被接受):

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

这是语法糖,但显然很多人为此功能提出了要求。但在获得批准之前,您必须自己计算迭代次数,或者使用带有Iterator 的常规 for 循环。

【讨论】:

【参考方案9】:

虽然提到了很多其他方法可以实现相同的目标,但我会为一些不满意的用户分享我的方法。我正在使用 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】:

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

【讨论】:

请注意,这需要 Arrays 对象的 .equals() 实现,它可以唯一地标识某个对象。 不是字符串的情况,如果某个字符串多次出现在数组中,您将只能获得第一次出现的索引,即使您已经在使用相同字符串迭代后面的项目.【参考方案11】:

如果您需要在 for-each 循环中使用计数器,您必须自己计算。据我所知,没有内置计数器。

【讨论】:

(我已经修复了问题中的那个错误。)【参考方案12】:

pax 的答案有一个“变体”... ;-)

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

【讨论】:

很好奇,与看似更清晰的i=0; i++; 方法相比,使用它有什么好处吗? 我猜你是否需要在 for 范围内的 doSomething 之后再次使用 i 索引。【参考方案13】:

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

int i=0;

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

其中 Type 可以是任何数据类型,types 是您申请循环的变量。

【讨论】:

请以可重现的代码格式提供您的答案。 这正是需要替代解决方案的方式。问题不在于类型,而在于以不同于手动计数的方式访问循环计数器的可能性。【参考方案14】:

我有点惊讶没有人提出以下建议(我承认这是一种懒惰的方法......); 如果 stringArray 是某种列表,您可以使用类似 stringArray.indexOf(S) 的东西来返回当前计数的值。

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

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

【讨论】:

由于整个循环的性能接近 O(n²),很难想象即使在少数情况下这会优于其他任何方法。对不起。【参考方案15】:

这是我如何做到这一点的一个例子。这将在 for each 循环中获取索引。希望这可以帮助。

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


    

【讨论】:

对不起,这不是回答问题。这不是关于访问内容,而是关于一个计数器多久循环已经被迭代了。 问题是在 for-each 样式循环中找出循环中的当前索引。 至少保留在这里并评价,因为在我看来这是一个类似的答案。感谢您的解释 Kosl2801 和 rumman0786

以上是关于有没有办法在 Java for-each 循环中访问迭代计数器?的主要内容,如果未能解决你的问题,请参考以下文章

有没有办法在 XSLT 转换中用应用模板替换 for-each?

2.24 Java基础总结 ①for-each循环②继承概念③全类名④方法重写

反编译看java for-each循环

For-Each 循环 Java 错误 ArrayIndexOutOfBoundsException

为啥 for-each 循环适用于数组? (爪哇)

For-Each循环Java错误ArrayIndexOutOfBoundsException