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

静态Iterable ITerableVerseList（最终列表l）{
返回新的Iterable（）{
公共迭代器迭代器（）{
返回新的迭代器（）{
ListIterator listIter=l.ListIterator（l.size（））；
公共布尔值hasNext（）{return listIter.hasPrevious（）；}
public T next（）{return listIter.previous（）；}
public void remove（）{listIter.remove（）；}
};
}
};
}

---

我刚刚发现一些

列表

实现有

下降迭代器（）

，这正是我所需要的。虽然对于

列表

没有通用的此类实现。这有点奇怪，因为我在

LinkedList

中看到的实现非常通用，可以处理任何

列表

提供以下功能：

List letters=不可修改的列表，共有（“a”、“b”、“c”）；
列表反转查看=列表反转（字母）；
System.out.println（reverseView）；//[c、b、a]

---

与集合.reverse不同，这纯粹是一个视图。。。它不会改变原始列表中元素的顺序。此外，对于可修改的原始列表，对原始列表和视图的更改都会反映在另一个列表中。

这并不完美，但如果使用list.listIterator（int-index），则可以在列表末尾获得一个双向listIterator：

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

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

//假设列表foo；
ListIterator li=foo.ListIterator（foo.size（））；
while（li.hasPrevious（））{
字符串curr=li.previous（）
}

java.util.Deque

具有

下降迭代器（）。它将返回一个浅层副本，这意味着它将包含指向相同对象的指针，因此您不必复制列表。然后只使用集合

因此

Collections.reverse(list.clone());

如果您使用的是
列表
，但无权访问
clone（）
，则可以使用：

List shallowCopy=List.subList（0，List.size（））；
收藏。反向（浅拷贝）；
我知道这是一篇老文章，但今天我在找类似的东西。最后，我自己编写了代码：

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个元素）

希望它能帮助某人。
您也可以这样做：

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

静态ArrayList反转返回（ArrayList）
{
if（alist==null | | alist.isEmpty（））
{ 
返回null；
}
ArrayList rlist=新的ArrayList（列表）；
收藏。反向（rlist）；
返回rlist；
}
如果我理解正确，那么这是一行代码。它对我有用

 Collections.reverse(yourList);

我用这个：

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

}

收藏。反向（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);

List nums=new ArrayList（）；
增加（61）；
增加（42）；
增补（83）；
增加（94）；
增加（15）；
//要对集合进行排序，请取消对下一行的注释
//集合。排序（nums）；
收藏。反向（nums）；
系统输出打印项次（nums）；

输出：15,94,83,42,61
您也可以在请求对象时反转位置：

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

List-stringList=newarraylist（Arrays.asList（“一”、“二”、“三”））；
stringList.stream（）.collect（Collectors.toCollection（LinkedList:：new））
.DestingingIterator（）。
forEachRemaining（System.out:：println）；//三，二，一
System.out.println（stringList）；//一，二，三
使用
反向（…）
java.util.Collections

类的方法。将列表作为参数传递，列表将被反转

Collections.reverse(list);

---

你能从相反的顺序开始构建列表吗？是的，它可以-java.uitl.list.listIterator（int）如果你访问此链接找到如何反转（修改）列表的答案，这就是答案：

Collections.reverse（list）

clone（）

通常会创建列表的副本。无论如何，

List#clone（）

也不存在。从技术上讲，您是对的，List接口本身不提供clone（）方法。但是ArrayList、LinkedList和Vector都可以。我只是查看了

clone（）

的实现。它确实是列表的完整副本（它只是不克隆列表中的每个对象，但这从来不是我所说的）。请注意，Collections.reverse返回void，因此您将丢失克隆引用。您需要首先将克隆分配给一个变量，然后对其进行排序。

子列表

不复制，它只提供基础列表的一个视图，因此反转此视图将反转基础列表。您的代码有一个问题-您可以将任何列表放入其中，但它始终会返回ArrayList（作为列表）。如果我需要LinkedList呢？最好修改myList并返回void。请注意，这并不是我真正想要的。我要求的是某种代理/视图，而不是副本。这不是列表视图。视图与副本相反。空列表的反向列表为空？？这不是列表视图。问题是番石榴是一个非常大的图书馆。参见讨论：和@Filipe de Lima Brito:ProGuard仍然是图书馆的最佳解决方案

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

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

Collections.reverse(list);