如何将集合转换为列表？

Question

我正在使用 Apache Collections 库中的 TreeBidiMap 。 我想对双精度值进行排序。

我的方法是使用以下方法检索值的 Collection：

Collection coll = themap.values();

这自然可以正常工作。

主要问题：我现在想知道如何将（不确定哪个是正确的）coll转换/转换为List，以便它可以排序了吗？

然后，我打算迭代排序的 List 对象，该对象应该按顺序排列，并使用 TreeBidiMap (themap) 获取适当的键code>themap.getKey(iterator.next()) 其中迭代器将位于 doubles 列表上。

Answer 1

List list = new ArrayList(coll);
Collections.sort(list);

正如 Erel Segal Halevi 在下面所说，如果 coll 已经是一个列表，您可以跳过第一步。 但这取决于 TreeBidiMap 的内部结构。

List list;
if (coll instanceof List)
  list = (List)coll;
else
  list = new ArrayList(coll);

Answer 2

像这样的东西应该可以工作，调用 ArrayList 构造函数 接受一个 Collection：

List theList = new ArrayList(coll);

Answer 3

我相信你可以这样写：

coll.stream().collect(Collectors.toList())

Answer 4

我认为如果 coll 已经是一个列表，Paul Tomblin 的答案可能是浪费的，因为它将创建一个新列表并复制所有元素。 如果 coll 包含许多元素，这可能需要很长时间。

我的建议是：

List list;
if (coll instanceof List)
  list = (List)coll;
else
  list = new ArrayList(coll);
Collections.sort(list);

Answer 5

Java 10 引入了 List#copyOf，它返回不可修改的 List，同时保留顺序：

List<Integer> list = List.copyOf(coll);

Answer 6

Collections.sort( new ArrayList( coll ) );

Answer 7

Java 8 及以上...

您可以使用 Streams 和 Collectors.toCollection( )。

考虑以下示例映射

Map<Integer, Double> map = Map.of(
    1, 1015.45,
    2, 8956.31,
    3, 1234.86,
    4, 2348.26,
    5, 7351.03
);

到 ArrayList

List<Double> arrayList = map.values()
                            .stream()
                            .collect(
                                Collectors.toCollection(ArrayList::new)
                            );

输出：[7351.03、2348.26、1234.86、8956.31、1015.45]

到已排序的ArrayList（升序）

List<Double> arrayListSortedAsc = map.values()
                                        .stream()
                                        .sorted()
                                        .collect(
                                            Collectors.toCollection(ArrayList::new)
                                        );

输出：[1015.45、1234.86、2348.26、7351.03、8956.31]

到已排序的ArrayList（降序）

List<Double> arrayListSortedDesc = map.values()
                                        .stream()
                                        .sorted(
                                            (a, b) -> b.compareTo(a)
                                        )
                                        .collect(
                                            Collectors.toCollection(ArrayList::new)
                                        );

输出：[8956.31、7351.03、2348.26、1234.86、1015.45]

到 LinkedList

List<Double> linkedList = map.values()
                                .stream()
                                .collect(
                                    Collectors.toCollection(LinkedList::new)
                                );

输出：[7351.03、2348.26、1234.86、8956.31、1015.45]

到 HashSet

Set<Double> hashSet = map.values()
                            .stream()
                            .collect(
                                Collectors.toCollection(HashSet::new)
                            );

输出：[2348.26、8956.31、1015.45、1234.86、7351.03]

到 PriorityQueue

PriorityQueue<Double> priorityQueue = map.values()
                                            .stream()
                                            .collect(
                                                Collectors.toCollection(PriorityQueue::new)
                                            );

输出：[1015.45、1234.86、2348.26、8956.31、7351.03]

参考

Java - 包 java.util.stream

Java - 包 java.util

Answer 8

@Kunigami：我认为您可能对 Guava 的 newArrayList 方法有误解。 它不会检查 Iterable 是否是 List 类型，而只是按原样返回给定的 List。 它总是创建一个新列表：

@GwtCompatible(serializable = true)
public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {
  checkNotNull(elements); // for GWT
  // Let ArrayList's sizing logic work, if possible
  return (elements instanceof Collection)
      ? new ArrayList<E>(Collections2.cast(elements))
      : newArrayList(elements.iterator());
}

Answer 9

您请求的是一个相当昂贵的操作，请确保您不需要经常执行此操作（例如在一个周期中）。

如果您需要它保持排序并且经常更新，您可以创建自定义集合。 例如，我想出了一个在引擎盖下包含 TreeBidiMap 和 TreeMultiset 的方案。 仅实施您需要的内容并关心数据完整性。

class MyCustomCollection implements Map<K, V> {
    TreeBidiMap<K, V> map;
    TreeMultiset<V> multiset;
    public V put(K key, V value) {
        removeValue(map.put(key, value));
        multiset.add(value);
    }
    public boolean remove(K key) {
        removeValue(map.remove(key));
    }
    /** removes value that was removed/replaced in map */
    private removeValue(V value) {
        if (value != null) {
            multiset.remove(value);
        }
    }
    public Set<K> keySet() {
        return Collections.unmodifiableSet(map.keySet());
    }
    public Collection<V> values() {
        return Collections.unmodifiableCollection(multiset);
    }
    // many more methods to be implemented, e.g. count, isEmpty etc.
    // but these are fairly simple
}

这样，您就可以从 values() 返回一个已排序 Multiset。 但是，如果您需要它是一个列表（例如，您需要类似数组的 get(index) 方法），则需要更复杂的东西。

为了简洁起见，我只返回不可修改的集合。 @Lino 提到的是正确的，按原样修改 keySet 或 values 集合会使其不一致。 我不知道有什么一致的方法可以使 values 可变，但是 keySet 如果使用 remove< 则可以支持 remove上面的 MyCustomCollection 类中的 /code> 方法。

Answer 10

使用流：

someCollection.stream().collect(Collectors.toList())

Answer 11

这是一个次优解决方案：

Collections.list(Collections.enumeration(coll));