Java'da bir listeyi ters sırada yineleme

Jenerikler kullanmak için bir kod parçası geçiriyorum. Bunu yapmak için bir argüman, for döngüsünün dizinleri takip etmekten veya açık bir yineleyici kullanmaktan çok daha temiz olmasıdır.

Vakaların yaklaşık yarısında, liste (ArrayList) bugün bir dizin kullanılarak ters sırada yineleniyor.

Birisi bunu yapmak için daha temiz bir yol önerebilir ( indexed for loopkoleksiyonlarla çalışırken ne zaman sevmediğimden ), ancak işe yarıyor mu?

 for (int i = nodes.size() - 1; i >= 0; i--) {
    final Node each = (Node) nodes.get(i);
    ...
 }

Not: JDK dışında yeni bağımlılıklar ekleyemiyorum.

Bunu dene:

// Substitute appropriate type.
ArrayList<...> a = new ArrayList<...>();

// Add elements to list.

// Generate an iterator. Start just after the last element.
ListIterator li = a.listIterator(a.size());

// Iterate in reverse.
while(li.hasPrevious()) {
  System.out.println(li.previous());
}

Guava teklifleri Lists#reverse(List)ve ImmutableList#reverse(). Guava için çoğu durumda olduğu gibi, argüman birImmutableList , böylece her durumda ilkini kullanabilirsiniz. Bunlar listenin yeni kopyalarını oluşturmaz, sadece listenin "ters çevrilmiş görünümlerini" oluşturur.

Misal

List reversed = ImmutableList.copyOf(myList).reverse();

Ben for döngüsü sözdizimini kullanarak mümkün olduğunu sanmıyorum. Önerebileceğim tek şey şöyle bir şey yapmaktır:

Collections.reverse(list);
for (Object o : list) {
  ...
}

... ama daha az verimli olacağı düşünüldüğünde bunun "daha temiz" olduğunu söyleyemem.

Seçenek 1: Listeyi Koleksiyonlar # reverse () ile ters çevirip foreach kullanmayı düşündünüz mü ?

Tabii ki, kodunuzu liste doğru sıralanacak şekilde yeniden düzenlemek de isteyebilirsiniz, böylece geri çevirmek zorunda kalmazsınız, bu da ekstra alan / zaman kullanır.

DÜZENLE:

Seçenek 2: Alternatif olarak, ArrayList yerine Deque kullanabilir misiniz ? İleri ve geri yinelemenize izin verecektir

DÜZENLE:

Seçenek 3: Diğerlerinin önerdiği gibi, listeyi tersine çevirecek bir Yineleyici yazabilirsiniz, işte bir örnek:

import java.util.Iterator;
import java.util.List;

public class ReverseIterator<T> implements Iterator<T>, Iterable<T> {

    private final List<T> list;
    private int position;

    public ReverseIterator(List<T> list) {
        this.list = list;
        this.position = list.size() - 1;
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return list.get(position--);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

}


List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");

for (String s : new ReverseIterator<String>(list)) {
    System.out.println(s);
}

LinkedListGenel arabirim yerine somut sınıfı kullanabilirsiniz List. Sonra descendingIteratorters yönde yineleme için bir var .

LinkedList<String > linkedList;
for( Iterator<String > it = linkedList.descendingIterator(); it.hasNext(); ) {
    String text = it.next();
}

Hiçbir yoktur Neden bilmiyorum descendingIteratorile ArrayList...

Bu eski bir soru, ama java8 dostu bir cevaptan yoksun. Akış API'sının yardımıyla listeyi tersine çevirmenin bazı yolları şunlardır:

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 3, 3, 7, 5));
list.stream().forEach(System.out::println); // 1 3 3 7 5

int size = list.size();

ListIterator<Integer> it = list.listIterator(size);
Stream.generate(it::previous).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

ListIterator<Integer> it2 = list.listIterator(size);
Stream.iterate(it2.previous(), i -> it2.previous()).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList)
IntStream.range(0, size).map(i -> size - i - 1).map(list::get)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList), less efficient due to sorting
IntStream.range(0, size).boxed().sorted(Comparator.reverseOrder())
    .map(list::get).forEach(System.out::println); // 5 7 3 3 1

İşte bir (denenmemiş) uygulaması ReverseIterable. Ne zaman iterator()denir yarattığı ve özel döndürür ReverseIteratorbasitçe çağrıları eşleyen uygulanmasını hasNext()etmek hasPrevious()ve bu aramaları next()eşlenir previous(). Bu ArrayList, tersi yönde aşağıdaki gibi tekrarlayabileceğiniz anlamına gelir :

ArrayList<String> l = ...
for (String s : new ReverseIterable(l)) {
  System.err.println(s);
}

Sınıf Tanımı

public class ReverseIterable<T> implements Iterable<T> {
  private static class ReverseIterator<T> implements Iterator {
    private final ListIterator<T> it;

    public boolean hasNext() {
      return it.hasPrevious();
    }

    public T next() {
      return it.previous();
    }

    public void remove() {
      it.remove();
    }
  }

  private final ArrayList<T> l;

  public ReverseIterable(ArrayList<T> l) {
    this.l = l;
  }

  public Iterator<T> iterator() {
    return new ReverseIterator(l.listIterator(l.size()));
  }
}

Listeler, performansın gerçek bir sorun olmaması için oldukça küçükse, reverse-class Listssınıfının -metod'u kullanılabilir Google Guava. Pretty for-each-code verir ve orijinal liste aynı kalır. Ayrıca, tersine çevrilmiş liste orijinal liste tarafından desteklenir, bu nedenle orijinal listede yapılacak herhangi bir değişiklik ters çevrilmiş listeye yansıtılacaktır.

import com.google.common.collect.Lists;

[...]

final List<String> myList = Lists.newArrayList("one", "two", "three");
final List<String> myReverseList = Lists.reverse(myList);

System.out.println(myList);
System.out.println(myReverseList);

myList.add("four");

System.out.println(myList);
System.out.println(myReverseList);

Aşağıdaki sonucu verir:

[one, two, three]
[three, two, one]
[one, two, three, four]
[four, three, two, one]

Bu, myList'in ters yinelemesinin şu şekilde yazılabileceği anlamına gelir:

for (final String someString : Lists.reverse(myList)) {
    //do something
}

Bir özel oluşturun reverseIterable.

Çok basit bir örnek:

List<String> list = new ArrayList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}

Kullanabilirsin ReverseListIterator Apache Commons-Koleksiyonları'ndan:

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/ReverseListIterator.html

Ayrıca Google koleksiyonları ters yöntemi bulundu .

Şuna benzeyen bir koda sahip olmak için:

List<Item> items;
...
for (Item item : In.reverse(items))
{
    ...
}

Bu kodu "In.java" adlı bir dosyaya yerleştirin:

import java.util.*;

public enum In {;
    public static final <T> Iterable<T> reverse(final List<T> list) {
        return new ListReverseIterable<T>(list);
    }

    class ListReverseIterable<T> implements Iterable<T> {
        private final List<T> mList;

        public ListReverseIterable(final List<T> list) {
            mList = list;
        }

        public Iterator<T> iterator() {
            return new Iterator<T>() {
                final ListIterator<T> it = mList.listIterator(mList.size());

                public boolean hasNext() {
                    return it.hasPrevious();
                }
                public T next() {
                    return it.previous();
                }
                public void remove() {
                    it.remove();
                }
            };
        }
    }
}

En az iki kez önerildiği gibi, descendingIteratora ile Deque, özellikle a ile kullanabilirsiniz LinkedList. For-each döngüsünü kullanmak istiyorsanız (yani, an var Iterable), şöyle bir sarmalayıcı oluşturabilir ve kullanabilirsiniz:

import java.util.*;

public class Main {

    public static class ReverseIterating<T> implements Iterable<T> {
        private final LinkedList<T> list;

        public ReverseIterating(LinkedList<T> list) {
            this.list = list;
        }

        @Override
        public Iterator<T> iterator() {
            return list.descendingIterator();
        }
    }

    public static void main(String... args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

        for (String s : new ReverseIterating<String>(list)) {
            System.out.println(s);
        }
    }
}

Sebep: "ArrayList ile neden descendingIterator olmadığını bilmiyorum ..."

Dizi listesi listeye veriler eklendiği sırada listeyi tutmadığından. Yani, asla Arraylist kullanmayın.

Bağlantılı liste, verileri listeye EKLE aynı sırada tutar.

Yani, benim örneğimde, kullanıcının fikrini bükmek ve yanlarından bir şey egzersiz yapmak için ArrayList () kullandım.

Bunun yerine

List<String> list = new ArrayList<String>();

KULLANIM:

List<String> list = new LinkedList<String>();

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}