Java의 목록에서 목록을 반대로 보는 방법은 무엇입니까?

목록에서 List#sublist하위 목록보기를 제공하는 것과 비슷한 방식으로 목록에서 목록보기를 반대로하고 싶습니다 . 이 기능을 제공하는 기능이 있습니까?

목록을 복사하거나 목록을 수정하고 싶지 않습니다.

이 경우 목록에서 적어도 역 반복자를 얻을 수 있다면 충분할 것입니다.

또한 이것을 직접 구현하는 방법을 알고 있습니다. Java가 이미 이와 같은 것을 제공하는지 묻고 있습니다.

데모 구현 :

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

방금 일부 List구현에 descendingIterator()필요한 것이 있음을 알게되었습니다 . 에 대한 일반적인 구현은 없지만 List. 내가 본 구현 LinkedList이 일반 적으로 작동하기에 충분하기 때문에 어떤 종류의 이상한가 List.

구아바 는 이것을 제공합니다 : Lists.reverse (List)

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

와 달리 Collections.reverse, 이것은 순전히 보기입니다 ... 원래 목록의 요소 순서를 변경하지 않습니다. 또한 수정 가능한 원본 목록을 사용하면 원본 목록과보기 모두에 대한 변경 내용이 다른쪽에 반영됩니다.

List에서 .clone () 메소드를 사용하십시오. 얕은 복사본을 반환하므로 동일한 개체에 대한 포인터가 포함되므로 목록을 복사 할 필요가 없습니다. 그런 다음 컬렉션을 사용하십시오.

에르고,

Collections.reverse(list.clone());

를 사용하고 List있고 액세스 clone()할 수없는 경우 subList()다음을 사용할 수 있습니다 .

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

내가 올바른 것으로 이해했다면 그것은 한 줄의 코드입니다.

 Collections.reverse(yourList);

정확히 우아하지는 않지만 List.listIterator (int index)를 사용하면 목록 끝까지 양방향 ListIterator를 얻을 수 있습니다.

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

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

Collections.reverse (nums) ... 실제로 요소의 순서를 반대로 바꿉니다. 아래 코드는 대단히 감사하겠습니다-

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

출력 : 15,94,83,42,61

java.util.Deque이 descendingIterator()- 당신이 경우 List이다 Deque, 당신이 사용할 수 있습니다.

나는 이것이 오래된 게시물이라는 것을 알고 있지만 오늘 나는 이와 같은 것을 찾고있었습니다. 결국 코드를 ​​직접 작성했습니다.

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

긴 목록에는 권장되지 않으며 전혀 최적화되지 않았습니다. 제어 된 시나리오를위한 일종의 쉬운 솔루션입니다 (내가 처리하는 목록은 100 개를 넘지 않습니다).

누군가에게 도움이되기를 바랍니다.

나는 이것을 사용한다 :

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

}

이처럼 :

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

당신은 또한 이것을 할 수 있습니다 :

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

객체를 요청할 때 위치를 반전시킬 수도 있습니다.

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

작은 크기의 목록의 경우 LinkedList다음과 같이 내림차순 반복자를 만들고 사용할 수 있습니다.

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

수업 reverse(...)방법을 사용하십시오 java.util.Collections. 목록을 매개 변수로 전달하면 목록이 반전됩니다.

Collections.reverse(list);