Par souci d'exhaustivité ...
Supposons que vous souhaitiez vraiment traiter les Mapvaleurs comme des Lists, mais que vous souhaitiez éviter de les copier Setà Listchaque fois.
Par exemple, vous appelez peut-être une fonction de bibliothèque qui crée un Set, mais vous passez votre Map<String, List<String>>résultat à une fonction de bibliothèque (mal conçue mais hors de vos mains) qui ne prend que Map<String, List<String>>, même si vous savez d'une manière ou d'une autre que les opérations qu'il fait avec le Lists sont également applicables à tout Collection(et donc à tout Set). Et pour une raison quelconque, vous devez éviter la surcharge de vitesse / mémoire de la copie de chaque ensemble dans une liste.
Dans ce cas de super niche, en fonction du comportement (peut-être inconnu) dont la fonction de bibliothèque a besoin dans vos Lists, vous pourrez peut-être créer une List vue sur chaque ensemble. Notez que cela est intrinsèquement dangereux (car les exigences de la fonction de bibliothèque de chacun Listpourraient vraisemblablement changer à votre insu), donc une autre solution devrait être préférée. Mais voici comment vous le feriez.
Vous devez créer une classe qui implémente l' Listinterface, prend un Setdans le constructeur et affecte cet ensemble à un champ, puis utilise cette interne Setpour implémenter l' ListAPI (dans la mesure du possible et souhaitée).
Notez que certains comportements List que vous ne pourrez tout simplement pas imiter sans stocker les éléments en tant que List, et certains comportements que vous ne pourrez imiter que partiellement. Encore une fois, cette classe n'est pas un remplacement sûr pour les Lists en général. En particulier, si vous savez que le cas d'utilisation nécessite des opérations liées à l'index ou une MUTATION List, cette approche irait très vite vers le sud.
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);
...