如何在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，这纯粹是一个视图 ...它不会改变原始列表中元素的顺序。此外，使用可修改的原始列表，对原始列表和视图的更改都会反映在另一个列表中。

在列表上使用.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);