可以以相反的顺序为Java中的每个循环做一个吗？

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

所以它转发到哪里：

for(String string: stringList){
//...do something
}

是否有某种方法可以针对每种语法以相反的顺序迭代stringList ？

为了清楚起见：我知道如何以相反的顺序迭代列表，但想知道（出于好奇的缘故）如何针对每种样式进行处理。

Collections.reverse方法实际上返回一个新列表，其中原始列表的元素以相反的顺序复制到该列表中，因此就原始列表的大小而言，它具有O（n）性能。

作为一种更有效的解决方案，您可以编写一个装饰器，该装饰器将List的反向视图呈现为Iterable。装饰器返回的迭代器将使用装饰列表的ListIterator以相反的顺序遍历元素。

例如：

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

您会像这样使用它：

import static Reversed.reversed;

...

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

有关列表，您可以使用Google Guava库：

for (String item : Lists.reverse(stringList))
{
    // ...
}

请注意，这不会颠倒整个集合，也不会做任何类似的事情-它只允许以相反的顺序进行迭代和随机访问。这比先反转集合更有效。Lists.reverse

要撤消任意可迭代项，您必须阅读所有内容，然后向后“重播”。

（如果你还没有使用它，我会彻底建议你看看番石榴。这是伟大的东西。）

List（与Set不同）是一个有序的集合，并且对其进行迭代确实会按合同保留订单。我本来希望Stack以相反的顺序进行迭代，但是不幸的是它没有。因此，我能想到的最简单的解决方案是：

for (int i = stack.size() - 1; i >= 0; i--) {
    System.out.println(stack.get(i));
}

我意识到这不是一个“针对每个”循环的解决方案。我宁愿使用for循环，也不愿引入像Google Collections这样的新库。

Collections.reverse（）也可以完成此工作，但它会更新列表，而不是以相反的顺序返回副本。

这将与原始列表混淆，还需要在循环外部调用。另外，您也不希望每次循环都执行反向操作-如果应用了其中之一，那会是真的Iterables.reverse ideas吗？

Collections.reverse(stringList);

for(String string: stringList){
//...do something
}

AFAIK在标准库中没有标准的“ reverse_iterator”类东西支持for-each语法，这已经是他们后来引入该语言的语法糖。

您可以执行类似for（Item element：myList.clone（）。reverse（））的操作并支付相关价格。

这似乎也与没有给您方便的方法进行昂贵的操作的明显现象相符-因为按照定义，列表可能具有O（N）随机访问的复杂性（您可以使用单链接实现接口），反向迭代最终可能是O（N ^ 2）。当然，如果您有ArrayList，则无需支付该价格。

这可能是一个选择。希望从上一个元素开始比从while循环到结束有更好的方法。

public static void main(String[] args) {        
    List<String> a = new ArrayList<String>();
    a.add("1");a.add("2");a.add("3");a.add("4");a.add("5");

    ListIterator<String> aIter=a.listIterator();        
    while(aIter.hasNext()) aIter.next();

    for (;aIter.hasPrevious();)
    {
        String aVal = aIter.previous();
        System.out.println(aVal);           
    }
}

截至评论：您应该能够使用Apache CommonsReverseListIterator

Iterable<String> reverse 
    = new IteratorIterable(new ReverseListIterator(stringList));

for(String string: reverse ){
    //...do something
}

正如@rogerdpack所说，您需要将包裹ReverseListIterator为一个Iterable。

并非没有编写一些自定义代码，这将为您提供一个枚举器，它将为您反转元素。

您应该能够通过创建Iterable的自定义实现来用Java做到这一点，该实现将以相反的顺序返回元素。

然后，您将实例化包装器（或调用该方法，即您拥有），该包装器将返回Iterable实现，该实现会反转for每个循环中的元素。

您可以使用Collections类http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html反转列表然后循环。

如果要对每种语法使用开箱即用的顺序并以相反的顺序进行，则需要反转集合。

以上所有答案都只能通过包装另一种方法或在外部调用一些外部代码来满足要求。

下面是从复制的解决方案中的Java第四版思考，章11.13.1 AdapterMethodIdiom ;

这是代码：

// The "Adapter Method" idiom allows you to use foreach
// with additional kinds of Iterables.
package holding;
import java.util.*;

@SuppressWarnings("serial")
class ReversibleArrayList<T> extends ArrayList<T> {
  public ReversibleArrayList(Collection<T> c) { super(c); }
  public Iterable<T> reversed() {
    return new Iterable<T>() {
      public Iterator<T> iterator() {
        return new Iterator<T>() {
          int current = size() - 1; //why this.size() or super.size() wrong?
          public boolean hasNext() { return current > -1; }
          public T next() { return get(current--); }
          public void remove() { // Not implemented
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
}   

public class AdapterMethodIdiom {
  public static void main(String[] args) {
    ReversibleArrayList<String> ral =
      new ReversibleArrayList<String>(
        Arrays.asList("To be or not to be".split(" ")));
    // Grabs the ordinary iterator via iterator():
    for(String s : ral)
      System.out.print(s + " ");
    System.out.println();
    // Hand it the Iterable of your choice
    for(String s : ral.reversed())
      System.out.print(s + " ");
  }
} /* Output:
To be or not to be
be to not or be To
*///:~

解决方法：

Collections.reverse(stringList).forEach(str -> ...);

或搭配番石榴：

Lists.reverse(stringList).forEach(str -> ...);

绝对是这个问题的最新答案。一种可能性是在for循环中使用ListIterator。它不像冒号语法那么干净，但是可以工作。

List<String> exampleList = new ArrayList<>();
exampleList.add("One");
exampleList.add("Two");
exampleList.add("Three");

//Forward iteration
for (String currentString : exampleList) {
    System.out.println(currentString); 
}

//Reverse iteration
for (ListIterator<String> itr = exampleList.listIterator(exampleList.size()); itr.hasPrevious(); /*no-op*/ ) {
    String currentString = itr.previous();
    System.out.println(currentString); 
}

ListIterator语法的功劳是“迭代Java列表的方式”