Converti Imposta in elenco senza creare un nuovo elenco

Sto usando questo codice per convertire un Setin un 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);
}

Voglio evitare di creare un nuovo elenco in ogni iterazione del ciclo. È possibile?

È possibile utilizzare il metodo List.addAll () . Accetta una raccolta come argomento e il tuo set è una raccolta.

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

MODIFICA: come risposta alla modifica della domanda.
È facile vedere che se si desidera avere a Mapcon Lists come valori, per avere k valori diversi, è necessario creare k elenchi diversi.
Pertanto: non è possibile evitare la creazione di questi elenchi, gli elenchi dovranno essere creati.

Possibile soluzione:
dichiarare il proprio Mapcome Map<String,Set>o Map<String,Collection>invece e inserire semplicemente il set.

Usa il costruttore per convertirlo:

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

Inoltre dalla libreria Guava Collect, puoi usare newArrayList(Collection):

Lists.newArrayList([your_set])

Questo sarebbe molto simile alla precedente risposta di amit , tranne per il fatto che non è necessario dichiarare (o istanziare) alcun listoggetto.

Possiamo usare un solo liner in Java 8:

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

Ecco un piccolo esempio:

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

la soluzione più semplice

Volevo un modo molto veloce per convertire il mio set in Elenco e restituirlo, quindi in una riga l'ho fatto

 return new ArrayList<Long>(mySetVariable);

È possibile utilizzare questo cambio di una riga: 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()])));
}  

Farei :

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

Dal momento che non è stato menzionato finora, a partire da Java 10 è possibile utilizzare il nuovo copyOfmetodo factory:

List.copyOf(set);

Dal Javadoc :

Restituisce un Elenco non modificabile contenente gli elementi della Raccolta fornita, nel suo ordine di iterazione.

Java 8 offre la possibilità di utilizzare flussi e puoi ottenere un elenco da Set<String> setStringcome:

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

Sebbene l'implementazione interna al momento fornisca un'istanza di 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);
    }

ma JDK non lo garantisce. Come menzionato qui :

Non vi sono garanzie sul tipo, la mutabilità, la serializzabilità o la sicurezza dei thread dell'elenco restituito; se è necessario un maggiore controllo sull'Elenco reso, utilizzare toCollection (Fornitore).

Nel caso in cui si desideri essere sempre sicuri, è possibile richiedere un'istanza specificatamente come:

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

Creo un staticmetodo semplice :

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

... o se vuoi impostare il tipo di Elenco puoi usare:

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

Recentemente ho trovato questo:

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

Per amor di completezza...

Supponiamo che tu voglia veramente trattare i Mapvalori come Lists, ma vuoi evitare di copiarli Setin Listogni volta.

Ad esempio, forse stai chiamando una funzione di libreria che crea una Set, ma stai passando il Map<String, List<String>>risultato a una funzione di libreria (mal progettata ma fuori dalle tue mani) che richiede solo Map<String, List<String>>, anche se in qualche modo sai che le operazioni che fa con Listsono ugualmente applicabili a qualsiasi Collection(e quindi a qualsiasi Set). E per qualche motivo è necessario evitare il sovraccarico di velocità / memoria della copia di ciascun set in un elenco.

In questo caso di super nicchia, a seconda del comportamento (forse inconoscibile) di cui la funzione di libreria necessita dai tuoi List, potresti essere in grado di creare una List vista su ogni set. Si noti che questo è intrinsecamente pericoloso (poiché i requisiti della funzione di libreria di ciascuno di essi Listpotrebbero presumibilmente cambiare a tua insaputa), quindi un'altra soluzione dovrebbe essere preferita. Ma ecco come lo faresti.

Dovresti creare una classe che implementa l' Listinterfaccia, prende un Setnel costruttore e assegna quel Set a un campo, e poi usi quello interno Setper implementare l' ListAPI (nella misura del possibile e desiderata).

Nota che alcuni comportamenti dell'elenco che semplicemente non sarai in grado di imitare senza memorizzare gli elementi come a List, e alcuni comportamenti che potrai imitare solo parzialmente. Ancora una volta, questa classe non è un rimpiazzo sicuro per Lists in generale. In particolare, se sai che il caso d'uso richiede operazioni relative all'indice o MUTAZIONI List, questo approccio andrebbe a sud molto velocemente.

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

Ho trovato questo funzionante e utile per creare un elenco da un set.

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