Por uma questão de completude ...
Diga que você realmente deseja tratar os Mapvalores como Lists, mas deseja evitar copiar os valores Setpara Listcada vez.
Por exemplo, talvez você esteja chamando uma função de biblioteca que cria a Set, mas está transmitindo o Map<String, List<String>>resultado para uma função de biblioteca (mal projetada, mas fora de suas mãos) que leva apenas Map<String, List<String>>, embora, de alguma maneira, você saiba que as operações que realiza com o Lists são igualmente aplicáveis a qualquer Collection(e, portanto, a qualquer Set). E, por algum motivo, você precisa evitar a sobrecarga de velocidade / memória de copiar cada conjunto em uma lista.
Nesse caso de super nicho, dependendo do comportamento (talvez incognoscível) que a função de biblioteca precisa de seus Lists, você poderá criar uma List visualização sobre cada conjunto. Observe que isso é inerentemente inseguro (como os requisitos de cada uma das funções da biblioteca Listpodem presumivelmente mudar sem que você saiba); portanto, outra solução deve ser preferida. Mas aqui está como você faria isso.
Você criaria uma classe que implementa a Listinterface, pega um Setno construtor e atribui esse conjunto a um campo e, em seguida, usa essa interna Setpara implementar a ListAPI (na medida do possível e desejada).
Observe que alguns comportamentos de lista que você simplesmente não será capaz de imitar sem armazenar os elementos como a List, e algum comportamento que você apenas poderá imitar parcialmente. Novamente, essa classe não é um substituto seguro para o Lists em geral. Em particular, se você souber que o caso de uso requer operações relacionadas ao índice ou MUTATING the List, essa abordagem seria muito rápida.
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);
...