Bagaimana cara mendapatkan tampilan daftar terbalik pada daftar di Jawa?

Saya ingin memiliki tampilan daftar terbalik pada daftar (dengan cara yang sama daripada List#sublistmemberikan tampilan sublist pada daftar). Apakah ada beberapa fungsi yang menyediakan fungsi ini?

Saya tidak ingin membuat salinan apa pun dari daftar atau memodifikasi daftar.

Akan cukup jika saya bisa mendapatkan setidaknya iterator terbalik pada daftar dalam kasus ini.

Juga, saya tahu cara mengimplementasikan ini sendiri. Saya hanya bertanya apakah Java sudah menyediakan sesuatu seperti ini.

Implementasi demo:

static <T> Iterable<T> iterableReverseList(final List<T> l) {
    return new Iterable<T>() {
        public Iterator<T> iterator() {
            return new Iterator<T>() {
                ListIterator<T> listIter = l.listIterator(l.size());                    
                public boolean hasNext() { return listIter.hasPrevious(); }
                public T next() { return listIter.previous(); }
                public void remove() { listIter.remove(); }                 
            };
        }
    };
}

Saya baru tahu bahwa beberapa Listimplementasi memiliki descendingIterator()apa yang saya butuhkan. Meskipun tidak ada implementasi seperti umum untuk List. Yang agak aneh karena implementasi yang saya lihat di LinkedListcukup umum untuk bekerja dengan siapa pun List.

Guava menyediakan ini: Lists.reverse (Daftar)

List<String> letters = ImmutableList.of("a", "b", "c");
List<String> reverseView = Lists.reverse(letters); 
System.out.println(reverseView); // [c, b, a]

Tidak seperti Collections.reverseini, ini murni pemandangan ... itu tidak mengubah urutan elemen dalam daftar asli. Selain itu, dengan daftar asli yang dapat dimodifikasi, perubahan pada daftar asli dan tampilan tercermin dalam yang lain.

Gunakan metode .clone () pada Daftar Anda. Ini akan mengembalikan salinan dangkal, yang berarti akan berisi pointer ke objek yang sama, sehingga Anda tidak perlu menyalin daftar. Kemudian gunakan saja Koleksi.

Jadi,

Collections.reverse(list.clone());

Jika Anda menggunakan Listdan tidak memiliki akses, clone()Anda dapat menggunakan subList():

List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);

Jika saya mengerti benar maka itu adalah satu baris kode. Ini bekerja untuk saya.

 Collections.reverse(yourList);

Tidak terlalu elegan, tetapi jika Anda menggunakan List.listIterator (indeks int) Anda bisa mendapatkan ListIterator dua arah ke akhir daftar:

//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());

while (li.hasPrevious()) {
   String curr = li.previous()
}

Collections.reverse (nums) ... Ini sebenarnya membalik urutan elemen. Kode di bawah ini harus dihargai -

List<Integer> nums = new ArrayList<Integer>();
nums.add(61);
nums.add(42);
nums.add(83);
nums.add(94);
nums.add(15);
//Tosort the collections uncomment the below line
//Collections.sort(nums); 

Collections.reverse(nums);

System.out.println(nums);

Output: 15,94,83,42,61

java.util.Dequememiliki descendingIterator()- jika Anda Listseorang Deque, Anda dapat menggunakannya.

Saya tahu ini adalah posting lama tapi hari ini saya mencari sesuatu seperti ini. Pada akhirnya saya menulis kode sendiri:

private List reverseList(List myList) {
    List invertedList = new ArrayList();
    for (int i = myList.size() - 1; i >= 0; i--) {
        invertedList.add(myList.get(i));
    }
    return invertedList;
}

Tidak disarankan untuk Daftar panjang, ini tidak dioptimalkan sama sekali. Ini semacam solusi mudah untuk skenario terkontrol (Daftar yang saya tangani tidak memiliki lebih dari 100 elemen).

Semoga ini bisa membantu seseorang.

Saya menggunakan ini:

public class ReversedView<E> extends AbstractList<E>{

    public static <E> List<E> of(List<E> list) {
        return new ReversedView<>(list);
    }

    private final List<E> backingList;

    private ReversedView(List<E> backingList){
        this.backingList = backingList;
    }

    @Override
    public E get(int i) {
        return backingList.get(backingList.size()-i-1);
    }

    @Override
    public int size() {
        return backingList.size();
    }

}

seperti ini:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list

Anda juga dapat melakukan ini:

static ArrayList<String> reverseReturn(ArrayList<String> alist)
{
   if(alist==null || alist.isEmpty())
   { 
       return null;
   }

   ArrayList<String> rlist = new ArrayList<>(alist);

   Collections.reverse(rlist);
   return rlist;
}

Anda juga dapat membalik posisi ketika Anda meminta objek:

Object obj = list.get(list.size() - 1 - position);

Untuk daftar ukuran kecil kita dapat membuat LinkedListdan kemudian dapat menggunakan iterator descending sebagai:

List<String> stringList = new ArrayList<>(Arrays.asList("One", "Two", "Three"));
stringList.stream().collect(Collectors.toCollection(LinkedList::new))
         .descendingIterator().
         forEachRemaining(System.out::println); // Three, Two, One
System.out.println(stringList); // One, Two, Three

Gunakan reverse(...)metode java.util.Collectionskelas. Lulus daftar Anda sebagai parameter dan daftar Anda akan terbalik.

Collections.reverse(list);