Der Vollständigkeit halber...
Angenommen, Sie möchten die Werte wirklichMap als Lists behandeln, aber Sie möchten vermeiden, sie jedes Mal Setin ein zu kopieren List.
Zum Beispiel rufen Sie vielleicht eine Bibliotheksfunktion auf, die eine erstellt Set, aber Sie übergeben Ihr Map<String, List<String>>Ergebnis an eine (schlecht gestaltete, aber nicht in Ihren Händen befindliche) Bibliotheksfunktion, die nur benötigt wird Map<String, List<String>>, obwohl Sie irgendwie wissen, dass die Operationen, die sie mit der ausführt Lists gelten gleichermaßen für alle Collection(und damit alle Set). Und aus irgendeinem Grund Sie den Geschwindigkeits- / Speicheraufwand beim Kopieren jedes Sets in eine Liste vermeiden.
In diesem Super-Nischen-Fall können Sie abhängig vom (möglicherweise nicht erkennbaren) Verhalten, das die Bibliotheksfunktion von Ihrem Lists benötigt, möglicherweise eine List Ansicht über jedes Set erstellen . Beachten Sie, dass dies von Natur aus unsicher ist (da sich die Anforderungen der Bibliotheksfunktion Listvermutlich ändern können, ohne dass Sie es wissen). Daher sollte eine andere Lösung bevorzugt werden. Aber so würden Sie es machen.
Sie würden eine Klasse erstellen, die die ListSchnittstelle implementiert , ein Setim Konstruktor übernimmt und dieses Set einem Feld zuweist und dieses interne dann verwendet, Setum die ListAPI zu implementieren (soweit möglich und gewünscht).
Beachten Sie, dass einige Listenverhaltensweisen Sie einfach nicht imitieren können, ohne die Elemente als zu speichern List, und einige Verhaltensweisen, die Sie nur teilweise imitieren können. Auch diese Klasse ist Listim Allgemeinen kein sicherer Ersatz für s. Insbesondere wenn Sie wissen, dass der Anwendungsfall indexbezogene Operationen oder MUTATING the erfordert List, würde dieser Ansatz sehr schnell nach Süden gehen.
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);
...