Làm thế nào để có được một khung nhìn danh sách đảo ngược trên một danh sách trong Java?

Tôi muốn có chế độ xem danh sách đảo ngược trong danh sách (theo cách tương tự như List#sublistcung cấp chế độ xem danh sách phụ trong danh sách). Có một số chức năng cung cấp chức năng này?

Tôi không muốn tạo bất kỳ loại bản sao nào của danh sách cũng như không sửa đổi danh sách.

Nó sẽ là đủ nếu tôi có thể nhận được ít nhất một trình vòng lặp ngược trong danh sách trong trường hợp này.

Ngoài ra, tôi biết làm thế nào để thực hiện điều này bản thân mình. Tôi chỉ hỏi rằng Java đã cung cấp một cái gì đó như thế này chưa.

Thực hiện 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(); }                 
            };
        }
    };
}

Tôi đã phát hiện ra rằng một số Listtriển khai có descendingIterator()những gì tôi cần. Mặc dù không có thực hiện chung như vậy cho List. Điều này là lạ vì thực hiện tôi đã thấy LinkedListlà đủ để làm việc với bất kỳ List.

Quả ổi cung cấp cái này: Lists.reverse (Danh sách)

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

Không giống như Collections.reverse, đây hoàn toàn là một khung nhìn ... nó không làm thay đổi thứ tự các yếu tố trong danh sách ban đầu. Ngoài ra, với danh sách gốc có thể sửa đổi, các thay đổi đối với cả danh sách gốc và chế độ xem được phản ánh trong danh sách khác.

Sử dụng phương thức .clone () trong Danh sách của bạn. Nó sẽ trả về một bản sao nông, nghĩa là nó sẽ chứa các con trỏ tới cùng các đối tượng, vì vậy bạn sẽ không phải sao chép danh sách. Sau đó, chỉ cần sử dụng Bộ sưu tập.

Ergo

Collections.reverse(list.clone());

Nếu bạn đang sử dụng Listvà không có quyền truy cập, clone()bạn có thể sử dụng subList():

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

Nếu tôi đã hiểu đúng thì đó là một dòng mã. Nó hoạt động với tôi.

 Collections.reverse(yourList);

Nó không chính xác thanh lịch, nhưng nếu bạn sử dụng List.listIterator (int index), bạn có thể nhận được ListIterator hai chiều đến cuối danh sách:

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

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

Bộ sưu tập.reverse (nums) ... Nó thực sự đảo ngược thứ tự của các phần tử. Mã dưới đây nên được đánh giá cao -

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

Đầu ra: 15,94,83,42,61

java.util.Dequecó descendingIterator()- nếu bạn Listlà một Deque, bạn có thể sử dụng nó.

Tôi biết đây là một bài viết cũ nhưng hôm nay tôi đã tìm kiếm một cái gì đó như thế này. Cuối cùng, tôi đã tự viết 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;
}

Không được đề xuất cho Danh sách dài, điều này hoàn toàn không được tối ưu hóa. Đó là một giải pháp dễ dàng cho các tình huống được kiểm soát (Danh sách tôi xử lý không có hơn 100 yếu tố).

Hy vọng nó sẽ giúp được ai đó.

Tôi sử dụng cái này:

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

}

như thế này:

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

Bạn cũng có thể làm điều này:

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

Bạn cũng có thể đảo ngược vị trí khi bạn yêu cầu một đối tượng:

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

Đối với danh sách có kích thước nhỏ, chúng ta có thể tạo LinkedListvà sau đó có thể sử dụng trình lặp giảm dần như:

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

Sử dụng reverse(...)phương pháp của java.util.Collectionslớp. Vượt qua danh sách của bạn dưới dạng tham số và danh sách của bạn sẽ bị đảo ngược.

Collections.reverse(list);