Come ordinare un set in un elenco in Java?

In Java, ho un Set, e voglio trasformarlo in un ordinato List. C'è un metodo nel java.util.Collectionspacchetto che lo farà per me?

La risposta fornita dall'OP non è la migliore. È inefficiente, in quanto crea un nuovo List e nuovo array un nuovo array non necessario. Inoltre, genera avvisi "non controllati" a causa dei problemi di sicurezza del tipo intorno agli array generici.

Invece, usa qualcosa del genere:

public static
<T extends Comparable<? super T>> List<T> asSortedList(Collection<T> c) {
  List<T> list = new ArrayList<T>(c);
  java.util.Collections.sort(list);
  return list;
}

Ecco un esempio di utilizzo:

Map<Integer, String> map = new HashMap<Integer, String>();
/* Add entries to the map. */
...
/* Now get a sorted list of the *values* in the map. */
Collection<String> unsorted = map.values();
List<String> sorted = Util.asSortedList(unsorted);

Set ordinato:

return new TreeSet(setIWantSorted);

o:

return new ArrayList(new TreeSet(setIWantSorted));

List myList = new ArrayList(collection);
Collections.sort(myList);

... Comunque dovrebbe fare il trucco. Aggiungi sapore con Generics dove applicabile.

Ecco come puoi farlo con i flussi di Java 8:

mySet.stream().sorted().collect(Collectors.toList());

o con un comparatore personalizzato:

mySet.stream().sorted(myComparator).collect(Collectors.toList());

Sempre sicuro utilizzare l'interfaccia Comparator o Comparable per fornire l'implementazione dell'ordinamento (se l'oggetto non è una classe String o Wrapper per i tipi di dati primitivi). Ad esempio per un'implementazione di comparatore per ordinare i dipendenti in base al nome

    List<Employees> empList = new LinkedList<Employees>(EmpSet);

    class EmployeeComparator implements Comparator<Employee> {

            public int compare(Employee e1, Employee e2) {
                return e1.getName().compareTo(e2.getName());
            }

        }

   Collections.sort(empList , new EmployeeComparator ());

Comparator è utile quando è necessario disporre di un algoritmo di ordinamento diverso sullo stesso oggetto (pronunciare emp name, emp salary, ecc.). L'ordinamento in modalità singola può essere implementato utilizzando l'interfaccia Comparable nell'oggetto richiesto.

Non esiste un singolo metodo per farlo. Usa questo:

@SuppressWarnings("unchecked")
public static <T extends Comparable> List<T> asSortedList(Collection<T> collection) {
  T[] array = collection.toArray(
    (T[])new Comparable[collection.size()]);
  Arrays.sort(array);
  return Arrays.asList(array);
}

È possibile convertire un set in un ArrayList, dove è possibile ordinare l' ArrayListutilizzo Collections.sort(List).

Ecco il codice:

keySet = (Set) map.keySet();
ArrayList list = new ArrayList(keySet);     
Collections.sort(list);

TreeSet sortedset = new TreeSet();
sortedset.addAll(originalset);

list.addAll(sortedset);

dove originalset = set non ordinato e list = l'elenco da restituire

@Jeremy Stein Volevo implementare lo stesso codice. Anche io volevo ordinare il set in list, quindi invece di usare Set ho convertito i valori set in List e li ho ordinati in base alla variabile. Questo codice mi ha aiutato,

set.stream().sorted(Comparator.comparing(ModelClassName::sortingVariableName)).collect(Collectors.toList());

Sto usando questo codice, che trovo più pratico della risposta accettata sopra:

List<Thing> thingList = new ArrayList<>(thingSet);
thingList.sort((thing1, thing2) -> thing1.getName().compareToIgnoreCase(thing2.getName()));