En aras de la exhaustividad...
Digamos que usted realmente hacer desea tratar los Mapvalores Lists, pero se quiere evitar copiar el Seten una Listcada vez.
Por ejemplo, tal vez estás llamando a una función de biblioteca que crea una Set, pero estás pasando tu Map<String, List<String>>resultado a una función de biblioteca (mal diseñada pero fuera de tu alcance) que solo toma Map<String, List<String>>, aunque de alguna manera sabes que las operaciones que realiza con Lists son igualmente aplicables a cualquiera Collection(y por lo tanto a cualquiera Set). Y por alguna razón , debe evitar la sobrecarga de velocidad / memoria de copiar cada Conjunto en una Lista.
En este caso de súper nicho, dependiendo del comportamiento (tal vez desconocido) que la función de biblioteca necesita de su Listcorreo electrónico, puede crear una List vista sobre cada Conjunto. Tenga en cuenta que esto es inherentemente inseguro (debido a que los requisitos de la función de biblioteca de cada uno Listpodrían presumiblemente cambiar sin que usted lo sepa), por lo que debería preferirse otra solución. Pero así es como lo harías.
Crearía una clase que implemente la Listinterfaz, tome un Seten el constructor y asigne ese conjunto a un campo, y luego use ese interno Setpara implementar la ListAPI (en la medida de lo posible y deseado).
Tenga en cuenta que algunos comportamientos de la Lista que simplemente no podrá imitar sin almacenar los elementos como a List, y algunos comportamientos que solo podrá imitar parcialmente. Nuevamente, esta clase no es un reemplazo seguro para Lists en general. En particular, si sabe que el caso de uso requiere operaciones relacionadas con el índice o MUTAR el List, este enfoque iría al sur muy rápido.
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);
...