Чи можна зробити а для кожного циклу в java у зворотному порядку?

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

Тож, де це робиться вперед:

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

Чи є спосіб ітерації stringList у зворотному порядку, використовуючи для кожного синтаксису?

Для наочності: я знаю, як скласти список у зворотному порядку, але хотів би знати (заради цікавості), як це зробити для кожного стилю.

Метод Collections.reverse фактично повертає новий список з елементами оригінального списку, скопійованими в нього у зворотному порядку, тому це має O (n) продуктивність щодо розміру вихідного списку.

Як більш ефективне рішення, ви можете написати декоратор, який представляє зворотний вигляд Списку як Ітерабельного. Ітератор, повернений вашим декоратором, використовує 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 перетворює всю колекцію чи щось подібне - вона просто дозволяє ітерацію та випадковий доступ у зворотному порядку. Це ефективніше, ніж спочатку скасувати колекцію.

Щоб скасувати довільну ітерабельну мережу, вам доведеться прочитати все це, а потім "перетворити" назад.

(Якщо ви не використовуєте його, я ретельно рекомендую вам поглянути на гуави . Це відмінний матеріал.)

Список (на відміну від Набору) - це упорядкована колекція, і повторення над нею зберігає порядок за контрактом. Я б очікував, що Стек повториться у зворотному порядку, але, на жаль, це не так. Тож найпростішим рішенням, про який я можу придумати, є таке:

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", який підтримує синтаксис "для кожного", який уже є синтаксичним цукром, який вони заносили пізно в мову.

Ви можете зробити щось на кшталт (елемент елемента: myList.clone (). Зворотний ()) і заплатити відповідну ціну.

Це також здається досить узгоджуваним із очевидним явищем, що не дає вам зручних способів робити дорогі операції - оскільки список, за визначенням, може мати складність O (N) випадкового доступу (ви можете реалізувати інтерфейс з односмуговою ланкою), зворотний ітерація може закінчитися O (N ^ 2). Звичайно, якщо у вас є ArrayList, ви не платите цю ціну.

Це може бути варіант. Сподіваюся, що є кращий спосіб почати з останнього елемента, ніж цикл до кінця.

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.

Не обійшлося без написання спеціального коду, який дасть вам перелік, який змінить елементи для вас.

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

Тоді ви будете інстанціювати обгортку (або викликати метод, що-у вас є), який би повернув Iterable реалізацію, яка перевертає елемент у для кожного циклу.

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

Якщо вам потрібно використати для кожного синтаксису поза полем, перейдіть у зворотному порядку.

Усі відповіді, наведені вище, виконують лише вимогу, будь то іншим способом або за допомогою зовнішнього коду;

Ось рішення, скопійоване з 4-го видання Thinking in 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 -> ...);

Однозначно пізня відповідь на це питання. Однією з можливостей є використання ListIterator в циклі for. Це не так чисто, як синтаксис двокрапки, але це працює.

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"