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

同样从Guava收集库，你可以使用newArrayList(收集):

Lists.newArrayList([your_set])

这与amit之前的回答非常相似，只是您不需要声明(或实例化)任何列表对象。

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

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

编辑:作为对问题编辑的回应。 很容易看出，如果您想要有一个带有列表作为值的Map，为了有k个不同的值，您需要创建k个不同的列表。 因此:您根本无法避免创建这些列表，必须创建这些列表。

可能的解决方法: 声明你的Map为Map<String,Set>或Map<String,Collection>，然后插入你的Set。

为了完整起见……

假设您确实希望将Map值视为列表，但希望避免每次都将Set复制到列表中。

例如，可能您调用了一个创建Set的库函数，但是您将Map<String, List<String>>结果传递给了一个只接受Map<String, List<String>>的库函数(设计很差，但不是您能控制的)，尽管您知道它对列表所做的操作同样适用于任何Collection(因此也适用于任何Set)。出于某种原因，您需要避免将每个Set复制到List所带来的速度/内存开销。

在这种特殊情况下，根据库函数需要从列表中获得的行为(可能是不可知的)，您可以在每个Set上创建一个List视图。注意，这本质上是不安全的(因为每个List中的库函数需求可能会在您不知情的情况下发生变化)，因此应该采用另一种解决方案。但你可以这样做。

您将创建一个实现List接口的类，在构造函数中接受一个Set并将该Set赋值给一个字段，然后使用该内部Set来实现List API(在可能和需要的范围内)。

请注意，如果不将元素存储为List，您将无法模仿某些List行为，而某些行为只能部分模仿。同样，这个类通常不是list的安全替代品。特别是，如果您知道用例需要与索引相关的操作或MUTATING 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);
...

我发现这工作很好，有用的从一个集合创建一个列表。

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

由于到目前为止还没有提到它，从Java 10开始，你可以使用新的copyOf工厂方法:

List.copyOf(set);

来自Javadoc:

按迭代顺序返回一个不可修改的List，其中包含给定Collection的元素。

注意，这将在底层创建一个新的列表(确切地说是ImmutableCollections$ListN)

在给定集合上调用Collection#toArray()，然后 将这些对象放入一个新数组中。