Par souci d'exhaustivité ...
Supposons que vous souhaitiez vraiment traiter les Map
valeurs comme des List
s, mais que vous souhaitiez éviter de les copier Set
à List
chaque 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 List
s 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 List
s, 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 List
pourraient 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' List
interface, prend un Set
dans le constructeur et affecte cet ensemble à un champ, puis utilise cette interne Set
pour implémenter l' List
API (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 List
s 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);
...