Convertir l'ensemble en liste sans créer de nouvelle liste

J'utilise ce code pour convertir un Seten un List:

Map<String, List<String>> mainMap = new HashMap<>();

for (int i=0; i < something.size(); i++) {
  Set<String> set = getSet(...); //returns different result each time
  List<String> listOfNames = new ArrayList<>(set);
  mainMap.put(differentKeyName, listOfNames);
}

Je veux éviter de créer une nouvelle liste à chaque itération de la boucle. Est-ce possible?

Vous pouvez utiliser la méthode List.addAll () . Il accepte une collection comme argument et votre ensemble est une collection.

List<String> mainList = new ArrayList<String>();
mainList.addAll(set);

EDIT: comme répondre à l'édition de la question.
Il est facile de voir que si vous voulez avoir un Mapavec Lists comme valeurs, afin d'avoir k valeurs différentes, vous devez créer k listes différentes.
Ainsi: Vous ne pouvez pas éviter de créer ces listes du tout, les listes devront être créées.

Solution possible:
déclarez votre Mapcomme un Map<String,Set>ou à la Map<String,Collection>place, et insérez simplement votre ensemble.

Utilisez le constructeur pour le convertir:

List<?> list = new ArrayList<?>(set);

Également à partir de la bibliothèque Guava Collect, vous pouvez utiliser newArrayList(Collection):

Lists.newArrayList([your_set])

Ce serait très similaire à la réponse précédente de amit , sauf que vous n'avez pas besoin de déclarer (ou d'instancier) un listobjet.

Nous pouvons utiliser un seul liner en Java 8:

List<String> list = set.stream().collect(Collectors.toList());

Voici un petit exemple:

public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        List<String> list = set.stream().collect(Collectors.toList());
}

la solution la plus simple

Je voulais un moyen très rapide de convertir mon jeu en liste et de le renvoyer, donc en une ligne, je l'ai fait

 return new ArrayList<Long>(mySetVariable);

Vous pouvez utiliser ce changement d'une ligne: Arrays.asList(set.toArray(new Object[set.size()]))

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); 
  mainMap.put(differentKeyName, Arrays.asList(set.toArray(new Object[set.size()])));
}  

Je ferais :

Map<String, Collection> mainMap = new HashMap<String, Collection>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName,set);
}

Comme il n'a pas été mentionné jusqu'à présent, à partir de Java 10, vous pouvez utiliser la nouvelle copyOfméthode d'usine:

List.copyOf(set);

Depuis le Javadoc :

Renvoie une liste non modifiable contenant les éléments de la collection donnée, dans son ordre d'itération.

Java 8 offre la possibilité d'utiliser des flux et vous pouvez obtenir une liste Set<String> setStringsous la forme:

List<String> stringList = setString.stream().collect(Collectors.toList());

Bien que l'implémentation interne fournisse à ce jour une instance de ArrayList:

public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

mais JDK ne le garantit pas. Comme mentionné ici :

Il n'y a aucune garantie sur le type, la mutabilité, la sérialisation ou la sécurité des threads de la liste retournée; si davantage de contrôle sur la liste retournée est requis, utilisez toCollection (fournisseur).

Si vous voulez toujours être sûr, vous pouvez demander une instance spécifiquement comme:

List<String> stringArrayList = setString.stream()
                     .collect(Collectors.toCollection(ArrayList::new));

Je crée une staticméthode simple :

public static <U> List<U> convertSetToList(Set<U> set)
{
    return new ArrayList<U>(set);
}

... ou si vous souhaitez définir le type de liste, vous pouvez utiliser:

public static <U, L extends List<U>> List<U> convertSetToList(Set<U> set, Class<L> clazz) throws InstantiationException, IllegalAccessException
{
    L list = clazz.newInstance();
    list.addAll(set);
    return list;
}

Récemment, j'ai trouvé ceci:

ArrayList<T> yourList = Collections.list(Collections.enumeration(yourSet<T>));

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);
...

J'ai trouvé que cela fonctionnait bien et utile pour créer une liste à partir d'un ensemble.

ArrayList < String > L1 = new ArrayList < String > ();
L1.addAll(ActualMap.keySet());
for (String x: L1) {
    System.out.println(x.toString());
}

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName, new ArrayList(set));
}