Set in Liste konvertieren, ohne eine neue Liste zu erstellen

Ich benutze diesen Code, um a Setin a umzuwandeln 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);
}

Ich möchte vermeiden, in jeder Iteration der Schleife eine neue Liste zu erstellen. Ist das möglich?

Sie können die List.addAll () -Methode verwenden. Es akzeptiert eine Sammlung als Argument, und Ihr Satz ist eine Sammlung.

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

BEARBEITEN: als Antwort auf die Bearbeitung der Frage.
Es ist leicht zu erkennen, dass Sie k verschiedene Listen erstellen müssen , wenn Sie a Mapmit Lists als Werte haben möchten , um k verschiedene Werte zu haben.
Also: Sie können das Erstellen dieser Listen überhaupt nicht vermeiden, die Listen müssen erstellt werden.

Mögliche
Umgehung : Deklarieren Sie Ihre Mapals Map<String,Set>oder oder Map<String,Collection>fügen Sie einfach Ihr Set ein.

Verwenden Sie den Konstruktor, um es zu konvertieren:

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

Auch aus der Guava Collect-Bibliothek können Sie Folgendes verwenden newArrayList(Collection):

Lists.newArrayList([your_set])

Dies wäre der vorherigen Antwort von amit sehr ähnlich , außer dass Sie kein listObjekt deklarieren (oder instanziieren) müssen .

In Java 8 können wir folgenden Liner verwenden:

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

Hier ist ein kleines Beispiel:

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());
}

die einfachste Lösung

Ich wollte einen sehr schnellen Weg, um mein Set in List umzuwandeln und zurückzugeben, also tat ich es in einer Zeile

 return new ArrayList<Long>(mySetVariable);

Sie könnten diese einzeilige Änderung verwenden: 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()])));
}  

Ich würde tun:

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

Da dies bisher noch nicht erwähnt wurde, können Sie ab Java 10 die neue copyOfFactory-Methode verwenden:

List.copyOf(set);

Aus dem Javadoc :

Gibt eine nicht änderbare Liste zurück, die die Elemente der angegebenen Sammlung in ihrer Iterationsreihenfolge enthält.

Java 8 bietet die Möglichkeit, Streams zu verwenden, und Sie können eine Liste erhalten von Set<String> setString:

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

Die interne Implementierung bietet jedoch ab sofort eine Instanz von 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);
    }

JDK garantiert dies jedoch nicht. Wie hier erwähnt :

Es gibt keine Garantie für den Typ, die Veränderlichkeit, die Serialisierbarkeit oder die Thread-Sicherheit der zurückgegebenen Liste. Wenn mehr Kontrolle über die zurückgegebene Liste erforderlich ist, verwenden Sie toCollection (Lieferant).

Wenn Sie immer sicher sein möchten, können Sie eine Instanz speziell anfordern als:

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

Ich erstelle eine einfache staticMethode:

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

... oder wenn Sie den Listentyp festlegen möchten, können Sie Folgendes verwenden:

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;
}

Kürzlich habe ich folgendes gefunden:

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

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

Ich fand das gut und nützlich, um eine Liste aus einem Set zu erstellen.

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