如何在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一起工作。

304565 次浏览
小开
最佳答案

番石榴提供了这个

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

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

小开

它不是很优雅，但是如果你使用List。listIterator(int index)你可以获得一个双向的listIterator到列表的末尾:

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


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

java.util.Deque有descendingIterator() -如果你的List是Deque，你可以使用它。

小开

使用List中的.clone()方法。它将返回一个浅拷贝，这意味着它将包含指向相同对象的指针，因此您不必复制列表。然后使用集合。

因此,

Collections.reverse(list.clone());

如果你正在使用List并且无法访问clone()，你可以使用subList():

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

我知道这是一个老帖子，但今天我正在寻找这样的东西。最后，我自己编写了代码:

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

不推荐用于长列表，这根本没有优化。对于受控场景，这是一种简单的解决方案(我处理的list元素不超过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;
}
小开

如果我理解正确，那么这是一行代码。它为我工作。

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


}

是这样的:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list
小开
< p > Collections.reverse (num)…它实际上颠倒了元素的顺序。 下面的代码应该非常感谢-

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、61

小开

当你请求一个对象时，你也可以反转位置:

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

对于小型列表，我们可以创建LinkedList，然后可以使用降序迭代器as:

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

提交答案