Java 将集合转换为列表而不创建新列表

我正在使用此代码将

集合

转换为

列表

：

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

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

Map mainMap=newhashmap（）；
for（int i=0；i

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

您可以使用该方法。它接受一个集合作为参数，而您的集合就是一个集合

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

List mainList=new ArrayList（）；
mainList.addAll（集合）；

编辑：作为对问题编辑的回应。
很容易看出，如果您想要有一个

Map

，其中

List

s作为值，为了有k个不同的值，您需要创建k个不同的列表。
因此：您根本无法避免创建这些列表，必须创建这些列表

可能的解决办法：
将您的

地图

声明为

地图

或

地图

，然后插入您的集合。

我会：

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

Map mainMap=newhashmap（）；
对于（inti=0；i
Map mainMap=newhashmap（）；
对于（int i=0；i也来自Guava Collect库，您可以使用
newArrayList（Collection）
：

这与前面amit的回答非常相似，只是您不需要声明（或实例化）任何
列表
对象。
使用构造函数转换它：

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

List List=newarraylist（set）；
我发现这个方法很好用，可以从集合中创建列表

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

ArrayListL1=新的ArrayList（）；
L1.addAll（ActualMap.keySet（））；
用于（字符串x:L1）{
System.out.println（x.toString（））；
}
您可以使用这一行更改：
Arrays.asList（set.toArray（新对象[set.size（）]））

Map mainMap=newhashmap（）；
对于（int i=0；i我创建了简单的
静态
方法：

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

公共静态列表转换器setToList（Set）
{
返回新的ArrayList（集合）；
}

…或者，如果要设置列表类型，可以使用：

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

public static List convertSetToList（Set-Set，Class-clazz）抛出实例化异常、非法访问异常
{
L list=clazz.newInstance（）；
列表。添加全部（集合）；
退货清单；
}
在Java 8中，我们可以使用以下一个行程序：

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

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

publicstaticvoidmain（字符串[]args）{
Set=新树集（）；
集合。添加（“A”）；
设置。添加（“B”）；
设置。添加（“C”）；
List List=set.stream（）.collect（Collectors.toList（））；
}
最近我发现：

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

arraylistyourlist=Collections.list（Collections.enumeration（yourSet））；
Java 8提供了使用流的选项，您可以从
Set-setString
中获取列表，如下所示：

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

但JDK并不保证。如前所述：

对于类型、可变性、序列化性或
返回列表的线程安全性；如果对返回的
列表是必需的，用于收集（供应商）

如果您希望确保始终，则可以请求实例，具体如下所示：

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

List stringArrayList=setString.stream（）
.collect（收集器.toCollection（ArrayList:：new））；

最简单的解决方案

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

 return new ArrayList<Long>(mySetVariable);

返回新的ArrayList（mySetVariable）；
为了完整起见

假设您确实希望将
映射
值视为
列表
s，但您希望避免每次将
集
复制到
列表中

例如，您可能正在调用一个库函数来创建一个
集
，但您正在将
映射
结果传递给一个（设计糟糕但无法控制）只接受
映射
的库函数，即使您知道它对
列表所做的操作同样适用于任何
集合
（因此也适用于任何
集合
）。出于某种原因，您需要避免将每个集合复制到列表的速度/内存开销

在这种超级小生境的情况下，根据库函数在
列表中需要的行为（可能是不可知的），您可以在每个集合上创建
列表
视图。请注意，这本身就是不安全的（因为每个
列表中的库函数的需求可能会在您不知道的情况下发生变化），所以应该首选另一种解决方案。但下面是您的做法

您需要创建一个类来实现
列表
接口，在构造函数中获取一个
集合
，并将该集合分配给一个字段，然后使用该内部
集合
来实现
列表
API（在可能和需要的范围内）

请注意，如果不将元素存储为
列表
，您将无法模拟某些列表行为，而您只能部分模拟某些行为。同样，该类通常不是
列表
的安全替代品。特别是，如果您知道用例需要与索引相关的操作或改变
列表
，这种方法会很快消失。

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);
...

公共类ListViewOfSet实现列表{
专用最终集包装集；
公共ListViewOfSet（Set-setToWrap）{this.wrappedSet=setToWrap；}
@重写公共int size（）{返回this.wrappedSet.size（）；}
@重写公共布尔值isEmpty（）{返回this.wrappedSet.isEmpty（）；}
@重写公共布尔包含（对象o）{返回this.wrappedSet.contains（o）；}
@重写公共java.util.Iterator Iterator（）{返回this.wrappedSet.Iterator（）；}
@覆盖公共对象
List<String> stringArrayList = setString.stream()
                     .collect(Collectors.toCollection(ArrayList::new));

 return new ArrayList<Long>(mySetVariable);

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);
...

List.copyOf(set);

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