Ik gebruik deze code om een Set
te 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 Map
met List
S 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 Map
als 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 copyOf
gebruiken:
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$ListN
om nauwkeurig te zijn) onder de kap van
- Bellen
Collection#toArray()
op de gegeven set en vervolgens - 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> setString
als:
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 static
methode:
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));
}