it-swarm.com.de

Set in Liste konvertieren, ohne eine neue Liste zu erstellen

Ich verwende diesen Code, um ein Set in ein List zu konvertieren:

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

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //returns different result each time
  List 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?

458

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

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

EDIT: als Antwort auf die Bearbeitung der Frage.
Es ist leicht zu erkennen, dass Sie, wenn Sie ein Map mit Lists als Werten haben möchten, um k verschiedene Werte zu haben, k verschiedene Listen erstellen müssen.
Also: Sie können es nicht vermeiden, diese Listen zu erstellen, die Listen müssen erstellt werden.

Mögliche Abhilfe:
Erklären Sie Ihr Map stattdessen als Map<String,Set> oder Map<String,Collection> und fügen Sie einfach Ihr Set ein.

753
amit

Verwenden Sie den Konstruktor, um es zu konvertieren:

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

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

Lists.newArrayList([your_set])

Dies wäre der vorherigen Antwort von amit sehr ähnlich, mit der Ausnahme, dass Sie kein list -Objekt deklarieren (oder instanziieren) müssen.

80
chaiyachaiya

In Java 8 können wir folgenden einen 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());
}
37
rajadilipkolli

die einfachste lösung

Ich wollte eine sehr schnelle Möglichkeit, mein Set in List umzuwandeln und es zurückzugeben, also tat ich dies in einer Zeile

 return new ArrayList<Long>(mySetVariable);
20

Sie können diese Änderung in einer Zeile 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()])));
}  
6
Saheed

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);
}
4
Jerome L

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

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

Obwohl die interne Implementierung ab sofort eine Instanz von ArrayList bereitstellt:

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 erwähnt hier :

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

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));
3
i_am_zero

Kürzlich habe ich folgendes gefunden:

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

Ich erstelle eine einfache static Methode:

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

... oder wenn Sie die Art der Liste 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;
}
2
thomas.adamjak

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());
}
1
Karthic.K

Der Vollständigkeit halber...

Angenommen, Sie möchten die Map-Werte wirklich als Listen behandeln, möchten jedoch vermeiden, dass das Set jedes Mal in eine Liste kopiert wird.

Zum Beispiel rufen Sie möglicherweise eine Bibliotheksfunktion auf, die ein Set erstellt, aber Sie übergeben Ihr Map <String, List> -Ergebnis an eine (schlecht gestaltete, aber nicht in Ihren Händen liegende) Bibliotheksfunktion, die nur Map <String, List> verwendet , obwohl Sie irgendwie wissen , dass die Operationen, die es mit den Listen ausführt, gleichermaßen auf jede Sammlung (und damit auf jede Menge) anwendbar sind. Und aus irgendeinem Grund müssen Sie den Geschwindigkeits-/Speicheraufwand beim Kopieren jedes Sets in eine Liste vermeiden.

In diesem Super-Nischenfall können Sie je nach dem (möglicherweise nicht erkennbaren) Verhalten der Bibliotheksfunktion in Ihren Listen möglicherweise eine Listenansicht erstellen . über jeden Satz. Beachten Sie, dass dies von Natur aus unsicher ist (da sich die Anforderungen der Bibliotheksfunktionen in den einzelnen Listen möglicherweise ändern könnten, ohne dass Sie es wissen). Daher sollte eine andere Lösung bevorzugt werden. Aber so würden Sie es machen.

Sie erstellen eine Klasse, die die List-Schnittstelle implementiert, nehmen ein Set im Konstruktor und weisen dieses Set einem Feld zu und implementieren dann mit diesem internen Set die List-API (soweit möglich und gewünscht).

Beachten Sie, dass Sie einige List-Verhaltensweisen einfach nicht imitieren können, ohne die Elemente als List zu speichern, und einige Verhaltensweisen, die Sie nur teilweise imitieren können. Auch diese Klasse ist kein sicherer Ersatz für Listen im Allgemeinen. Insbesondere, wenn Sie wissen, dass der Anwendungsfall indexbezogene Operationen oder das MUTIEREN der Liste erfordert, 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 set = getSet(...);
ListViewOfSet listOfNames = new ListViewOfSet(set);
...
0
Daniel Avery