Converteer Set naar List zonder nieuwe lijst te maken

Ik gebruik deze code om een ​​Sette converteren naar een 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);
}

Ik wil vermijden om een ​​nieuwe lijst te maken in elke iteratie van de lus. Is dat mogelijk?

1, Autoriteit 100%

U kunt de Lijst.Addall () methode. Het accepteert een verzameling als een argument en uw set is een verzameling.

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

bewerken: zoals reageren op de bewerking van de vraag.

Het is gemakkelijk om te zien dat als u een Mapmet ListS als waarden, om K verschillende waarden te hebben, moet u K anders maken lijsten.

Dus: u kunt niet vermijden dat u deze lijsten helemaal kunt maken, de lijsten moeten worden gemaakt.

Mogelijk werk rondom:

Verklaar uw Mapals een Map<String,Set>of Map<String,Collection>in plaats daarvan en plaats gewoon je set.

2, Autoriteit 52%

Gebruik constructor om het te converteren:

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

3, Autoriteit 10%

Ook vanuit de Guava Collect-bibliotheek kunt u newArrayList(Collection)gebruiken:

Lists.newArrayList([your_set])

Dit zou erg lijken op het vorige antwoord van amit, behalve dat u geen list-object hoeft te declareren (of te maken).

Antwoord 4, autoriteit 6%

We kunnen de volgende one liner gebruiken in Java 8:

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

Hier is een klein voorbeeld:

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

Antwoord 5, autoriteit 4%

de eenvoudigste oplossing

Ik wilde een zeer snelle manier om mijn set naar List te converteren en terug te sturen, dus in één regel deed ik dat

return new ArrayList<Long>(mySetVariable);

Antwoord 6

Omdat het tot nu toe niet is genoemd, kunt u vanaf Java 10 de nieuwe fabrieksmethode copyOfgebruiken:

List.copyOf(set);

Van de Javadoc:

retourneert een niet-gemodificeerde lijst met de elementen van de gegeven verzameling, in de iteratieorder.

Merk op dat dit een nieuwe lijst maakt (ImmutableCollections$ListNom nauwkeurig te zijn) onder de kap van

1. Bellen Collection#toArray()op de gegeven set en vervolgens
2. zetten deze objecten in een nieuwe array.

7

ik zou doen:

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

8

U kunt deze One Line-wijziging gebruiken: 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()])));
}  

9

Java 8 biedt de optie om stromen te gebruiken en u kunt een lijst krijgen van Set<String> setStringals:

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

Hoewel de interne implementatie vanaf nu een exemplaar van ArrayList:

biedt

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

maar JDK niet garanderen. Zoals vermeld hier :

Er zijn geen garanties op het type, de veranderlijkheid, serializability, of
draad-veiligheid van de lijst die wordt geretourneerd; als er meer controle over de teruggekeerde
Lijst nodig is, gebruik toCollection (Supplier).

In het geval u wilt zeker altijd zijn dan kunt u een verzoek voor een instantie met name als:

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

10

Ik maak eenvoudige staticmethode:

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

… of als u wilt instellen type List die u kunt gebruiken:

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

11

Onlangs vond ik deze:

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

Antwoord 12

Ik vond dit prima werken en handig om een lijst te maken van een set.

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

13

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