一个人可以按照相反的顺序在java中执行每个循环吗？ [英] Can one do a for each loop in java in reverse order?

问题描述

我需要使用Java以相反的顺序遍历List。

所以在这里它转发：

  for（String string ：stringList）{
 //...do something 
} 
  

有一种方法可以按照相反的顺序使用为每个语法迭代stringList？

为了清楚起见：我知道如何迭代一个列表顺序，但想知道（为好奇的缘故）如何在中为每个风格。

解决方案

不要使用Collections.reverse方法，它实际上会颠倒原始列表。如果你使用它：

错误的方法！
$ b

Collections.reverse（new ArrayList （stringList））

为了避免修改原始文件，这将返回一个新列表，原始列表的元素以相反的顺序复制，而且这样的表现和空间要求的原始列表的大小。

作为一个更有效的解决方案，你可以写一个类作为可迭代泛型的List的颠倒视图。例如：

  public class Reversed< T>实现了Iterable< T> {
 private final List< T>原版的; 
 
 public Reversed（List< T> original）{
 this.original = original; 
} 
 
 public Iterator< T> iterator（）{
 final ListIterator< T> i = original.listIterator（original.size（））; 
 
 return new Iterator< T>（）{
 public boolean hasNext（）{return i.hasPrevious（）; } 
 public T next（）{return i.previous（）; } 
 public void remove（）{i.remove（）; } 
}; 
} 
 
 public static< T>逆转< T>颠倒（List< T> original）{
 return new Reversed< T>（original）; 
 
 
 
 
 $ b $你可以像这样使用它：
  import static Reversed.reversed; 
 
 ... 
 
 List< String> someStrings = getSomeStrings（）; 
 for（String s：reversed（someStrings））{
 doSomethingWith（s）; 
} 
  
 
I need to run through a List in reverse order using Java. 

So where this does it forwards:
for(String string: stringList){
//...do something
}
Is there some way to iterate the stringList in reverse order using the for each syntax?

For clarity: I know how to iterate a list in reverse order but would like to know (for curiosity's sake ) how to do it in the for each style.
解决方案
Do not use the Collections.reverse method it actually reverses the original list in place.  If you use it:

Wrong way!

Collections.reverse(new ArrayList(stringList)) 

to avoid modifying the original, this returns a new list with the elements of the original list copied into it in reverse order, and such has O(n) performance and space requirements with regards to the size of the original list.

As a more efficient solution, you could write a class that presents a reversed view of a List as an Iterable generic. The iterator returned by your class would use the ListIterator of the decorated list to walk over the elements in reverse order.

For example:
public class Reversed<T> implements Iterable<T> {
    private final List<T> original;

    public Reversed(List<T> original) {
        this.original = original;
    }

    public Iterator<T> iterator() {
        final ListIterator<T> i = original.listIterator(original.size());

        return new Iterator<T>() {
            public boolean hasNext() { return i.hasPrevious(); }
            public T next() { return i.previous(); }
            public void remove() { i.remove(); }
        };
    }

    public static <T> Reversed<T> reversed(List<T> original) {
        return new Reversed<T>(original);
    }
}
And you would use it like:
import static Reversed.reversed;

...

List<String> someStrings = getSomeStrings();
for (String s : reversed(someStrings)) {
    doSomethingWith(s);
}


                        
这篇关于一个人可以按照相反的顺序在java中执行每个循环吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！