Iterasi melalui daftar dalam urutan terbalik di java

Saya memigrasi sepotong kode untuk menggunakan obat generik. Salah satu argumen untuk melakukannya adalah bahwa for loop jauh lebih bersih daripada melacak indeks, atau menggunakan iterator eksplisit.

Dalam sekitar setengah kasus, daftar (sebuah ArrayList) sedang diulang dalam urutan terbalik dengan menggunakan indeks hari ini.

Dapatkah seseorang menyarankan cara yang lebih bersih untuk melakukan ini (karena saya tidak suka indexed for loopketika bekerja dengan koleksi), meskipun itu berhasil?

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

Catatan: Saya tidak bisa menambahkan dependensi baru di luar JDK.

Coba ini:

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

Jambu biji menawarkan Lists#reverse(List)dan ImmutableList#reverse(). Seperti dalam kebanyakan kasus untuk Guava, mantan delegasi ke yang terakhir jika argumennya adalahImmutableList , sehingga Anda dapat menggunakan yang pertama dalam semua kasus. Ini tidak membuat salinan baru dari daftar tetapi hanya "pandangan terbalik" darinya.

Contoh

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

Saya tidak berpikir itu mungkin menggunakan sintaks for loop. Satu-satunya hal yang dapat saya sarankan adalah melakukan sesuatu seperti:

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

... tapi saya tidak akan mengatakan ini "bersih" mengingat itu akan menjadi kurang efisien.

Opsi 1: Sudahkah Anda berpikir untuk membalikkan Daftar dengan Koleksi # reverse () dan kemudian menggunakan foreach?

Tentu saja, Anda mungkin juga ingin memperbaiki kode Anda sehingga daftar tersebut dipesan dengan benar sehingga Anda tidak perlu membalikkannya, yang menggunakan ruang / waktu ekstra.

EDIT:

Opsi 2: Atau, dapatkah Anda menggunakan Deque alih-alih ArrayList? Ini akan memungkinkan Anda untuk beralih ke depan dan ke belakang

EDIT:

Opsi 3: Seperti yang disarankan orang lain, Anda bisa menulis Iterator yang akan masuk daftar secara terbalik, berikut adalah contohnya:

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

Anda bisa menggunakan kelas konkret LinkedListalih-alih antarmuka umum List. Maka Anda memiliki descendingIteratoruntuk iterasi dengan arah sebaliknya.

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

Tidak tahu mengapa tidak ada descendingIteratordengan ArrayList...

Ini adalah pertanyaan lama, tetapi tidak memiliki jawaban ramah java8. Berikut adalah beberapa cara membalikkan daftar, dengan bantuan Streaming API:

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

Berikut adalah implementasi (belum diuji) dari a ReverseIterable. Ketika iterator()dipanggil itu membuat dan mengembalikan ReverseIteratorimplementasi pribadi , yang hanya memetakan panggilan hasNext()ke hasPrevious()dan panggilan ke next()dipetakan ke previous(). Ini berarti Anda dapat beralih secara ArrayListterbalik sebagai berikut:

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

Definisi kelas

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

Jika daftar tersebut cukup kecil sehingga kinerja bukanlah masalah nyata, orang dapat menggunakan reverse-metod dari -class Listsin Google Guava. Menghasilkan for-eachkode- cantik , dan daftar asli tetap sama. Juga, daftar terbalik didukung oleh daftar asli, sehingga setiap perubahan ke daftar asli akan tercermin dalam daftar terbalik.

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

Menghasilkan hasil sebagai berikut:

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

Yang berarti bahwa iterasi balik dari myList dapat ditulis sebagai:

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

Buat custom reverseIterable.

Contoh yang sangat sederhana:

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) {
  ...
}

Anda dapat menggunakan ReverseListIteratordari Apache Commons-Collections:

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

Ditemukan juga metode reverse collections google .

Untuk memiliki kode yang terlihat seperti ini:

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

Masukkan kode ini ke file yang disebut "In.java":

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

Seperti yang telah disarankan setidaknya dua kali, Anda dapat menggunakan descendingIterator dengan Deque, khususnya dengan a LinkedList. Jika Anda ingin menggunakan untuk-setiap loop (yaitu, memiliki Iterable), Anda dapat membuat dan menggunakan pembungkus seperti ini:

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

Alasan: "Tidak tahu mengapa tidak ada descendingIterator dengan ArrayList ..."

Karena daftar array tidak menyimpan daftar dalam urutan yang sama seperti data telah ditambahkan ke daftar. Jadi, jangan pernah gunakan Arraylist.

Daftar tertaut akan menyimpan data dalam urutan ADD yang sama.

Jadi, di atas dalam contoh saya, saya menggunakan ArrayList () untuk membuat pengguna memutar pikiran mereka dan membuat mereka berolahraga sesuatu dari sisi mereka.

Alih-alih ini

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

MENGGUNAKAN:

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) {
  ...
}