Konwertuj Ustaw na listę bez tworzenia nowej listy

Używam tego kodu do konwersji Setna 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);
}

Chcę uniknąć tworzenia nowej listy w każdej iteracji pętli. Czy to jest możliwe?

Możesz użyć metody List.addAll () . Akceptuje kolekcję jako argument, a twój zestaw jest kolekcją.

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

EDYCJA: w odpowiedzi na edycję pytania.
Łatwo jest zauważyć, że jeśli chcesz mieć Mapze Lists jako wartości, aby mieć różne wartości k, trzeba utworzyć k różnych list.
Zatem: Nie można w ogóle uniknąć tworzenia tych list, listy będą musiały zostać utworzone.

Możliwe obejście:
zadeklaruj Mapjako Map<String,Set>lub Map<String,Collection>zamiast, i po prostu wstaw swój zestaw.

Użyj konstruktora, aby go przekonwertować:

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

Również z biblioteki Guava Collect możesz użyć newArrayList(Collection):

Lists.newArrayList([your_set])

Byłoby to bardzo podobne do poprzedniej odpowiedzi z amit , z tym wyjątkiem, że nie musisz deklarować (ani instynktować) żadnego listobiektu.

W Javie 8 możemy użyć jednego linera:

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

Oto jeden mały przykład:

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

najprostsze rozwiązanie

Chciałem bardzo szybko przekonwertować mój zestaw na List i zwrócić go, więc zrobiłem to w jednym wierszu

 return new ArrayList<Long>(mySetVariable);

Możesz użyć tej zmiany jednej linii: 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()])));
}  

Chciałbym zrobić :

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

Ponieważ nie wspomniano do tej pory, od wersji Java 10 można korzystać z nowej copyOfmetody fabrycznej:

List.copyOf(set);

Z Javadoc :

Zwraca niemodyfikowalną listę zawierającą elementy danej kolekcji w kolejności iteracji.

Java 8 zapewnia opcję korzystania ze strumieni i możesz uzyskać listę z Set<String> setString:

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

Chociaż wewnętrzna implementacja zapewnia obecnie wystąpienie 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);
    }

ale JDK tego nie gwarantuje. Jak wspomniano tutaj :

Nie ma gwarancji na rodzaj, zmienność, serializację lub bezpieczeństwo wątków zwracanej listy; jeśli wymagana jest większa kontrola nad zwracaną listą, użyj funkcji toCollection (dostawca).

Jeśli chcesz być zawsze pewien, możesz poprosić o wystąpienie, w szczególności jako:

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

Tworzę prostą staticmetodę:

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

... lub jeśli chcesz ustawić typ listy, możesz użyć:

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

Ostatnio znalazłem to:

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

Ze względu na kompletność ...

Powiedz, że naprawdę chcesz traktować Mapwartości jako Lists, ale chcesz uniknąć kopiowania Setdo za Listkażdym razem.

Na przykład, może wywołujesz jedną funkcję biblioteczną, która tworzy Set, ale przekazujesz swój Map<String, List<String>>wynik do (słabo zaprojektowanej, ale wymykającej się z ręki) funkcji bibliotecznej, która bierze tylko Map<String, List<String>>, chociaż jakoś wiesz, że operacje, które wykonuje z Lists mają jednakowe zastosowanie do dowolnych Collection(a zatem dowolnych Set). I z jakiegoś powodu musisz unikać narzutu / pamięci związanego z kopiowaniem każdego zestawu do listy.

W tym bardzo niszowym przypadku, w zależności od (być może niepoznawalnego) zachowania funkcji biblioteki Listwymaganej od ciebie , możesz być w stanie stworzyć List widok każdego zestawu. Zauważ, że jest to z natury niebezpieczne (ponieważ wymagania funkcji bibliotecznych dla każdej z nich Listmogą prawdopodobnie ulec zmianie bez twojej wiedzy), dlatego należy preferować inne rozwiązanie. Ale oto jak to zrobisz.

Utworzyłbyś klasę, która implementuje Listinterfejs, bierze Setkonstruktora i przypisuje ten zestaw do pola, a następnie używa tego wewnętrznego Setdo implementacji Listinterfejsu API (w możliwym zakresie i pożądanym).

Zwróć uwagę, że niektóre zachowania List po prostu nie będą w stanie naśladować bez przechowywania elementów jako a List, a niektóre zachowania będą tylko częściowo możliwe do naśladowania. Ponownie, ta klasa nie jest Listogólnie bezpiecznym zamiennikiem dla s. W szczególności, jeśli wiesz, że przypadek użycia wymaga operacji związanych z indeksem lub MUTOWANIA List, to podejście pójdzie bardzo szybko na południe.

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

Uważam, że to działa dobrze i przydatne do tworzenia listy z zestawu.

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