Como ordeno um conjunto para uma lista em Java?

Em Java, eu tenho um Sete quero transformá-lo em um classificado List. Existe um método no java.util.Collectionspacote que fará isso por mim?

A resposta fornecida pelo OP não é a melhor. É ineficiente, pois cria uma nova List e uma nova matriz desnecessária. Além disso, gera avisos "não verificados" devido aos problemas de segurança de tipo em torno de matrizes genéricas.

Em vez disso, use algo como isto:

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

Aqui está um exemplo de uso:

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

Conjunto classificado:

return new TreeSet(setIWantSorted);

ou:

return new ArrayList(new TreeSet(setIWantSorted));

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

... deve fazer o truque no entanto. Adicione sabor com genéricos, quando aplicável.

Veja como você pode fazer isso com o Streams do Java 8:

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

ou com um comparador personalizado:

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

Sempre seguro usar a interface Comparator ou Comparable para fornecer implementação de classificação (se o objeto não for uma classe String ou Wrapper para tipos de dados primitivos). Como exemplo de uma implementação de comparador para classificar funcionários com base no 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 ());

O comparador é útil quando você precisa ter um algoritmo de classificação diferente no mesmo objeto (por exemplo, nome do emp, salário, etc.). A classificação em modo único pode ser implementada usando a interface Comparável no objeto necessário.

Não existe um método único para fazer isso. Usa isto:

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

Você pode converter um conjunto em um ArrayList, onde é possível classificar o ArrayListuso Collections.sort(List).

Aqui está o código:

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

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

list.addAll(sortedset);

onde originalset = conjunto não classificado e lista = a lista a ser retornada

@ Jeremy Stein Eu queria implementar o mesmo código. Assim como eu queria classificar o conjunto para a lista, então, em vez de usar o Conjunto, converti os valores do conjunto em Lista e classifique essa lista por uma variável. Esse código me ajudou,

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

Estou usando esse código, que acho mais prático do que a resposta aceita acima:

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