将 Set 转换为 List 而不创建新 List

Question

我正在使用此代码将 Set 转换为 List：

Map<String, List<String>> mainMap = new HashMap<>();

for (int i=0; i < something.size(); i++) {
  Set<String> set = getSet(...); //returns different result each time
  List<String> listOfNames = new ArrayList<>(set);
  mainMap.put(differentKeyName, listOfNames);
}

我想避免在循环的每次迭代中创建新列表。这可能吗？

Answer 1

您可以使用 List.addAll() 方法。它接受一个 Collection 作为参数，并且您的集合是一个 Collection。

List<String> mainList = new ArrayList<String>();
mainList.addAll(set);

编辑：作为对问题编辑的回应。

很容易看出，如果你想要一个以List作为值的Map，为了有k个不同的值，你需要创建k个不同的值列表。

因此：您根本无法避免创建这些列表，必须创建这些列表。

可能的解决方法：

将您的 Map 声明为 Map 或 Map，然后插入您的集合。

Answer 2

使用构造函数来转换它：

List<?> list = new ArrayList<>(set);

Answer 3

同样在 Guava Collect 库中，您可以使用 newArrayList(Collection)：

Lists.newArrayList([your_set])

这与 amit 之前的答案非常相似，只是您不需要声明（或实例化）任何list对象。

Answer 4

我们可以在 Java 8 中使用以下一个衬线：

List<String> list = set.stream().collect(Collectors.toList());

这是一个小示例：

public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        List<String> list = set.stream().collect(Collectors.toList());
}

注意： 这种使用流创建的方式会产生内存损失。如果需要避免创建新内存，则避免使用此解决方案

Answer 5

最简单的解决方案

我想要一种非常快速的方法将我的集合转换为列表并返回它，所以我在一行中做了

 return new ArrayList<Long>(mySetVariable);

Answer 6

由于到目前为止尚未提及，从 Java 10 开始，您可以使用新的 copyOf 工厂方法：

List.copyOf(set);

来自 Javadoc：

返回一个不可修改的列表包含给定 Collection 的元素（按其迭代顺序）。

请注意，这会创建一个新列表（ImmutableCollections$ListN 准确地说，通过在

1. 给定的集合上调用 Collection#toArray() 然后
2. 放置这些对象 在幕后到一个新的数组中。

Answer 7

为了完整起见......

假设您确实确实希望将Map值视为List，但您希望避免复制每次将 Set 放入 List 中。

例如，也许您正在调用一个创建 Set 的库函数，但您将 Map> 结果传递给一个（很差-设计但不在你手中）只需要 Map> 的库函数，即使你以某种方式知道它对List 同样适用于任何Collection（因此也适用于任何Set）。 由于某种原因，您需要避免将每个集合复制到列表的速度/内存开销。

在这种超级利基的情况下，根据库函数在您的 List 中需要的（可能不可知的）行为，您也许能够创建一个 List 视图 在每组上。请注意，这本质上是不安全的（因为每个 List 中的库函数的要求可能会在您不知情的情况下发生变化），因此应首选其他解决方案。但你可以这样做。

您将创建一个实现 List 接口的类，在构造函数中采用 Set 并将该 Set 分配给一个字段，然后使用该内部 Set< /code> 实现 List API（在可能的情况下和需要的范围内）。

请注意，如果不将元素存储为 List，您将无法模仿某些列表行为，而您只能部分模仿某些行为。同样，一般来说，此类并不是 List 的安全替代品。特别是，如果您知道用例需要与索引相关的操作或修改 List，那么这种方法很快就会失败。

public class ListViewOfSet<U> implements List<U> {
    private final Set<U> wrappedSet;
    public ListViewOfSet(Set<U> setToWrap) { this.wrappedSet = setToWrap; }

    @Override public int size() { return this.wrappedSet.size(); }
    @Override public boolean isEmpty() { return this.wrappedSet.isEmpty(); }
    @Override public boolean contains(Object o) { return this.wrappedSet.contains(o); }
    @Override public java.util.Iterator<U> iterator() { return this.wrappedSet.iterator(); }
    @Override public Object[] toArray() { return this.wrappedSet.toArray(); }
    @Override public <T> T[] toArray(T[] ts) { return this.wrappedSet.toArray(ts); }
    @Override public boolean add(U e) { return this.wrappedSet.add(e); }
    @Override public boolean remove(Object o) { return this.wrappedSet.remove(o); }
    @Override public boolean containsAll(Collection<?> clctn) { return this.wrappedSet.containsAll(clctn); }
    @Override public boolean addAll(Collection<? extends U> clctn) { return this.wrappedSet.addAll(clctn); }
    @Override public boolean addAll(int i, Collection<? extends U> clctn) { throw new UnsupportedOperationException(); }
    @Override public boolean removeAll(Collection<?> clctn) { return this.wrappedSet.removeAll(clctn); }
    @Override public boolean retainAll(Collection<?> clctn) { return this.wrappedSet.retainAll(clctn); }
    @Override public void clear() { this.wrappedSet.clear(); }
    @Override public U get(int i) { throw new UnsupportedOperationException(); }
    @Override public U set(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public void add(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public U remove(int i) { throw new UnsupportedOperationException(); }
    @Override public int indexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public int lastIndexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator() { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator(int i) { throw new UnsupportedOperationException(); }
    @Override public List<U> subList(int i, int i1) { throw new UnsupportedOperationException(); }
}

...
Set<String> set = getSet(...);
ListViewOfSet<String> listOfNames = new ListViewOfSet<>(set);
...

Answer 8

我会这样做：

Map<String, Collection> mainMap = new HashMap<String, Collection>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName,set);
}

Answer 9

您可以使用这一行更改：Arrays.asList(set.toArray(new Object[set.size()]))

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); 
  mainMap.put(differentKeyName, Arrays.asList(set.toArray(new Object[set.size()])));
}  

Answer 10

Java 8 提供了使用流的选项，您可以从 Set 获取列表。 setString as：

List<String> stringList = setString.stream().collect(Collectors.toList());

虽然目前内部实现提供了ArrayList的实例：

public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

但JDK并不保证它。正如这里提到的：

不保证类型、可变性、可序列化性或
返回的列表的线程安全；如果对返回的有更多控制
列表为必填项，请使用 toCollection(Supplier)。

如果您想始终确保，那么您可以专门请求一个实例，如下所示：

List<String> stringArrayList = setString.stream()
                     .collect(Collectors.toCollection(ArrayList::new));

Answer 11

我创建简单的 static 方法：

public static <U> List<U> convertSetToList(Set<U> set)
{
    return new ArrayList<U>(set);
}

...或者如果您想设置列表类型，您可以使用：

public static <U, L extends List<U>> List<U> convertSetToList(Set<U> set, Class<L> clazz) throws InstantiationException, IllegalAccessException
{
    L list = clazz.newInstance();
    list.addAll(set);
    return list;
}

Answer 12

最近我发现了这个：

ArrayList<T> yourList = Collections.list(Collections.enumeration(yourSet<T>));

Answer 13

我发现这工作正常并且对于从集合创建列表很有用。

ArrayList < String > L1 = new ArrayList < String > ();
L1.addAll(ActualMap.keySet());
for (String x: L1) {
    System.out.println(x.toString());
}

Answer 14

您可以将 Set 转换为 List，而无需添加排序信息（例如排序），只是将其存储在地图中。

因为 Set 是无序的，并且没有添加排序信息，所以不应该使用 List，因为它将包含随机排序的数据，并且所有与有序数据相关的方法都将被模糊的。

您应该使用 Collection 接口，它在地图中同时接受 Set 和 List 。这样，当您使用多态性而不是复制数据时，不需要额外的内存。

Map<String, Collection<String>> mainMap = new HashMap<>();

for (int i=0; i < something.size(); i++) {
  Set<String> set = getSet(...); //returns different result each time
  mainMap.put(differentKeyName, set);
}

免责声明：我对类似答案的编辑被拒绝，因此我添加了自己的答案以及其他信息< /em>

Answer 15

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName, new ArrayList(set));
}