如何在 Java 中获得列表的反向列表视图？

Question

我想在列表上有一个反向列表视图（与 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 一起使用。

Answer 1

更新 2024.06.16：

在 Emmanuel Bourg 发表精彩评论后，我又看了一眼查看代码并将其升级为现代风格的 null 安全，并纳入了他的出色建议。原始代码位于最后一条水平线下方。

它与最新版本的 Java 更加一致，即，利用 null 是一个类型漏洞，改变方法参数是一个类型漏洞代码味道，并且可变性被限制在一个很小的块内。尽可能在单个方法中编写代码，以提高 FP 可组合性（而不是较弱且容易出错的 OOP 可重用性）。

---

对于使用 Java 21 或更高版本的任何人，请使用 List.reversed()。

对于使用 Java 8 到 Java 20 的任何人...

1. 想要防范 null
2. 不想修改传递的参数，List（强烈的代码味道）
3. 想要返回不可修改的 List
4. 不想使用像 Guava 这样的第三方库
5. 想要一个遵循 Java Collection API Stream 的函数流畅的调用风格
6. 想要看到现代风格的代码（并摆脱 20 世纪 90 年代末非常类似 C 的代码）
7. 想要转向表达式（并远离语句）
8. 想要尽可能避免重新实现（在此情况下）在这种情况下，通过调用面向突变的命令性方法 Collections.reverse()（已存在于 Java Collections API 中）

...这是我生成的一个有用的解决方案：

/**
 * Returns a {@link Collections#unmodifiableList} with the contained instances in reverse order.
 *
 * @param list the list to copy from while reversing ({@code null} safe)
 * @param <T> the type of instances contained in the {@link list}
 * @return a {@link Collections#unmodifiableList} with the contained instances in reverse order
 */
public static <T> List<T> reverse(List<T> list) {
  return Optional.ofNullable(list)
      .filter(listNonNull ->
         !listNonNull.isEmpty())
      .map(listNonEmpty -> {
        if (listNonEmpty.size() == 1) {
          return Collections.unmodifiableList(listNonEmpty);
        }

        var listNonEmptyCopy = new ArrayList<>(listNonEmpty);
        Collections.reverse(listNonEmptyCopy);

        return Collections.unmodifiableList(listNonEmptyCopy);
      })
      .orElse(List.of());
}

---

最初发布的代码 已在上面更新（请勿使用）：

/**
 * Reverse the order of the instances returning an unmodifiable list.
 *
 * @param list the list to copy from while reversing
 * @param <T> the type of instances contained in the list
 * @return an unmodifiable list with the contained instances in reverse order
 */
public static <T> List<T> reverse(List<T> list) {
  if (list.size() > 1) {
    var size = list.size();

    return IntStream.range(0, size)
        .mapToObj(index -> list.get(size - 1 - index))
        .toList();
  } else if (list.size() == 1) {
    return list;
  }

  return List.of();
}

Answer 2

您还可以这样做：

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 3

在列表上使用 .clone() 方法。它将返回一个浅表副本，这意味着它将包含指向相同对象的指针，因此您不必复制列表。然后只需使用集合即可。

因此，

Collections.reverse(list.clone());

如果您使用的是 List 并且无权访问 clone() 您可以使用 subList()：

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

Answer 4

Guava 提供了以下内容：Lists.reverse(List)

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

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

Answer 5

如果我理解正确，那么它就是一行代码。它对我有用。

 Collections.reverse(yourList);

Answer 6

它并不完全优雅，但如果你使用 List.listIterator(int index) ，你可以得到一个到列表末尾的双向 ListIterator ：

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

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

Answer 7

我用这个：

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

Answer 8

从 Java 21 开始，出现了一个新接口 SequencedCollection （它是 <代码>列表）。它具有方法 reversed() 提供集合的逆序视图：

jshell> List.of(1, 2, 3, 4, 5).reversed()
$1 ==> [5, 4, 3, 2, 1]

Answer 9

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

Answer 10

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

Answer 11

我知道这是一篇旧文章，但今天我正在寻找类似的内容。最后我自己写了代码：

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

希望它对某人有帮助。

Answer 12

由于 Java 21 使用 List.reversed。

返回此集合的逆序视图。相遇顺序
返回视图中元素的数量与遇到顺序相反
该集合中的元素。反向排序会影响所有
顺序敏感的操作，包括对视图集合的操作
返回的视图。如果收集实施允许
对此视图的修改，修改“直写”到
底层集合。对基础集合的更改可能或
在此反向视图中可能不可见，具体取决于
实施。

所以你对原始列表有一个相反的看法。

Answer 13

您还可以在请求对象时反转位置：

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

Answer 14

对于小型列表，我们可以创建 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