Làm thế nào để đảo ngược một danh sách trong Java?

Question

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

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.

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

---

Ngoài ra, tôi biết cách tự thực hiện việc này. Tôi chỉ hỏi nếu Java đã cung cấp một cái gì đó như thế này.

Demo thực hiện:

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 chỉ đã phát hiện ra rằng một số List triển khai có descendingIterator() đó là những gì tôi cần. Mặc dù không có triển khai chung như vậy cho List. Đó là loại kỳ lạ bởi vì việc thực hiện tôi đã thấy trong LinkedList là đủ chung để làm việc với bất kỳ List.

Answer 1

Guava cung cấp này: Lists.reverse(List)

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 xem ... nó không làm thay đổi thứ tự các phần 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 gốc khác.

Answer 2

của nó không chính xác tao nhã, nhưng nếu bạn sử dụng List.listIterator (chỉ số int), bạn có thể nhận được một 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() 
} 

Answer 3

java.util.Deque có descendingIterator() - nếu bạn là List a Deque, bạn có thể sử dụng nó.

Answer 4

Sử dụng phương thức .clone() trên Danh sách của bạn. Nó sẽ trả về một bản sao nông, có nghĩa là nó sẽ chứa các con trỏ đến cùng một đố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 một List và không có quyền truy cập vào clone() bạn có thể sử dụng subList():

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

Answer 5

Tôi biết đây là một bài 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 khuyến nghị cho danh sách dài, điều này không được tối ưu hóa chút nào. Đó là một giải pháp dễ dàng cho các kịch bản được kiểm soát (danh sách tôi xử lý không có nhiều hơn 100 phần tử).

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

Answer 6

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

Answer 7

Nếu tôi đã hiểu đúng thì nó là một dòng mã Nó làm việc cho tôi.

Collections.reverse(yourList); 

Answer 8

tôi sử dụng 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 

Answer 9

Collections.reverse (nums) ... Nó thực sự đảo ngược thứ tự của các yếu tố. Dưới mã nên được nhiều đánh giá cao -

List<Integer> nums = new ArrayList<Integer>(); 
nums.add(61); 
nums.add(42); 
nums.add(83); 
nums.add(94); 
nums.add(15); 

Collections.sort(nums); 

Collections.reverse(nums); 

System.out.println(nums); 

Answer 10

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

Answer 11

Đối với danh sách có kích thước nhỏ, chúng tôi có thể tạo LinkedList và sau đó có thể sử dụng giảm dần iterator như:

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