Java'daki bir listede ters liste görünümü nasıl alınır?

Bir listede ters liste görünümü olmasını istiyorum (listede bir alt liste List#sublistgörünümü sağlar gibi). Bu işlevi sağlayan bazı işlevler var mı?

Listenin herhangi bir kopyasını almak veya listeyi değiştirmek istemiyorum.

Bu durumda bir listede en azından ters bir yineleyici alabilsem yeterli olurdu.

Ayrıca, bunu kendim nasıl uygulayacağımı biliyorum. Sadece Java'nın zaten böyle bir şey sağlayıp sağlamadığını soruyorum.

Demo uygulaması:

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

Sadece bazı Listuygulamaların descendingIterator()ihtiyacım olan şey olduğunu öğrendim. Genel bir uygulama olmamasına rağmen List. Bu biraz garip çünkü gördüğüm uygulama LinkedListherhangi biriyle çalışmak için yeterince genel List.

Guava bunu sağlar: Lists.reverse (Liste)

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

Bunun aksine Collections.reverse, bu sadece bir görünümdür ... orijinal listedeki öğelerin sırasını değiştirmez. Ayrıca, değiştirilebilir orijinal bir listeyle, hem orijinal listede hem de görünümde yapılan değişiklikler diğerine yansıtılır.

Listenizdeki .clone () yöntemini kullanın. Sığ bir kopya döndürür, yani aynı nesnelere işaretçiler içereceğinden listeyi kopyalamanız gerekmez. Ardından Koleksiyonlar'ı kullanın.

Ergo,

Collections.reverse(list.clone());

A kullanıyorsanız Listve erişiminiz clone()yoksa şunları kullanabilirsiniz subList():

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

Eğer doğru anladıysam o zaman bir kod satırıdır. Benim için çalıştı.

 Collections.reverse(yourList);

Tam olarak zarif değil, ancak List.listIterator (int dizini) kullanırsanız, listenin sonuna iki yönlü bir ListIterator alabilirsiniz:

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

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

Collections.reverse (nums) ... Aslında öğelerin sırasını tersine çevirir. Aşağıdaki kod çok takdir edilmelidir -

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

Çıktı: 15,94,83,42,61

java.util.Dequevardır descendingIterator()- eğer Listbir ise Deque, bunu kullanabilirsiniz.

Bunun eski bir yazı olduğunu biliyorum ama bugün böyle bir şey arıyordum. Sonunda kodu kendim yazdım:

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

Uzun Listeler için önerilmez, bu hiç optimize edilmez. Kontrollü senaryolar için kolay bir çözümdür (Kullandığım Listelerin 100'den fazla öğesi yoktur).

Umarım birine yardımcı olur.

Bunu kullanıyorum:

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

}

bunun gibi:

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

Bunu da yapabilirsiniz:

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

Ayrıca, bir nesne talep ettiğinizde konumu tersine çevirebilirsiniz:

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

Küçük boyutlu liste için aşağıdaki LinkedListgibi inen yineleyiciyi oluşturabilir ve kullanabiliriz:

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

Kullanım reverse(...)yöntemleri java.util.Collectionssınıfına. Listenizi parametre olarak ilettiğinizde listeniz tersine çevrilir.

Collections.reverse(list);