Можно ли сделать каждый цикл в java в обратном порядке?

Question

Мне нужно запустить список в обратном порядке с помощью Java.

Так где это делает его вперед:

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

Есть ли какой-нибудь способ итерирует StringList в обратном порядке, используя для каждого синтаксиса?

Для ясности: Я знаю, как перебирать список в обратном порядке, но хотел бы знать (ради любопытства), как это сделать в для каждого стиля.

Answer 1

Не используйте метод Collections.reverse он фактически переворачивает оригинальный список на месте. Если вы используете его:

Неправильный путь!

Collections.reverse(new ArrayList(stringList))

, чтобы избежать изменений оригинала, это возвращает новый список с элементами исходного списка скопированного в нее в обратном порядке, и такие есть O (N) требования к производительности и пространства в отношении размера первоначального списка.

В качестве более эффективного решения вы можете написать класс, который представляет собой обратный вид списка как универсального типа 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); 
} 

Answer 2

AFAIK В стандартной библиотеке нет стандартного типа «reverse_iterator», который поддерживает синтаксический синтаксис, который уже является синтаксическим сахаром, который они запоздали на языке.

Вы можете сделать что-то вроде (элемент Item: myList.clone(). Reverse()) и оплатить соответствующую цену.

Это также кажется вполне согласующимся с очевидным явлением, когда вы не предоставляете вам удобные способы выполнения дорогостоящих операций - поскольку список по определению может иметь сложность случайного доступа O (N) (вы можете реализовать интерфейс с односторонним доступом, link), обратная итерация может оказаться O (N^2). Конечно, если у вас есть ArrayList, вы не платите эту цену.

Answer 3

Не забудьте написать какой-то пользовательский код, который даст вам перечислитель, который изменит элементы для вас.

Вы должны иметь возможность сделать это на Java, создав пользовательскую реализацию Iterable, которая вернет элементы в обратном порядке.

Затем вы должны создать экземпляр обертки (или вызвать метод, what-have-you), который вернет реализацию Iterable, которая обращает элемент в каждом цикле.

Answer 4

Вы можете использовать класс Collections http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html, чтобы отменить список, а затем цикл.

Answer 5

Вам нужно будет отменить свою коллекцию, если вы хотите использовать для каждого синтаксиса из коробки и перейти в обратном порядке.

Answer 6

Для получения списка, вы можете использовать Google Guava Library:

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

Обратите внимание, что Lists.reverseне реверсировать всю коллекцию, или сделать что-нибудь подобное - он просто позволяет итерация и произвольный доступ, в обратный порядок. Это более эффективно, чем обратная сборка.

Чтобы отменить произвольное итерируемое, вам нужно будет прочитать все, а затем «воспроизвести» его назад.

(Если вы не используете его, я бы тщательно рекомендуем вам взглянуть на Guava. Это отличный материал.)

Answer 7

Это испортит с первоначальным списком, а также должна быть вызвана вне цикла. Также вы не хотите выполнять обратное при каждом цикле - это верно, если был применен один из Iterables.reverse ideas?

Collections.reverse(stringList); 

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

Answer 8

Это может быть вариант. Надеюсь, что есть лучший способ начать с последнего элемента, чем до цикла 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);   
    } 
} 

Answer 9

Список (в отличие от Set) представляет собой упорядоченную коллекцию и итерирование по ней сохраняет заказ по контракту. Я бы ожидал, что Stack будет итератировать в обратном порядке, но, к сожалению, это не так. Таким образом, самое простое решение, которое я могу придумать это:

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

Я понимаю, что это не «для каждого» цикла решения. Я предпочел бы использовать цикл for, а не новую библиотеку, например коллекцию Google.

Collections.reverse() также выполняет эту работу, но он обновляет список, а не возвращает копию в обратном порядке.

Answer 10

По the comment: Вы должны быть в состоянии использовать Apache Commons ReverseListIterator

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

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

Как @rogerdpack said, вам нужно обернуть ReverseListIterator как Iterable.

Answer 11

Все ответы выше соответствуют только требованию, либо путем переноса другого метода, либо вызова внешнего кода за пределами;

Вот решение скопировано из мышления в Java 4-е издание, глава 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 
*///:~