¿Cómo clasifico un conjunto en una lista en Java?

En Java, tengo un Set, y quiero convertirlo en un ordenado List. ¿Hay algún método en el java.util.Collectionspaquete que haga esto por mí?

La respuesta proporcionada por el OP no es la mejor. Es ineficiente, ya que crea un nuevo List y matriz innecesaria. Además, genera advertencias "no verificadas" debido a los problemas de seguridad de tipo en torno a las matrices genéricas.

En cambio, use algo como esto:

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

Aquí hay un ejemplo 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 ordenado:

return new TreeSet(setIWantSorted);

o:

return new ArrayList(new TreeSet(setIWantSorted));

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

... Sin embargo, debería hacer el truco. Agregue sabor con genéricos cuando corresponda.

Así es como puedes hacerlo con las transmisiones de Java 8:

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

o con un comparador personalizado:

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

Siempre es seguro usar la interfaz Comparador o Comparable para proporcionar una implementación de clasificación (si el objeto no es una clase String o Wrapper para tipos de datos primitivos). Como ejemplo para una implementación de comparación para clasificar a los empleados según su nombre

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

El comparador es útil cuando necesita tener un algoritmo de clasificación diferente en el mismo objeto (diga nombre emp, salario emp, etc.). La ordenación de modo único se puede implementar mediante el uso de una interfaz comparable en el objeto requerido.

No hay un método único para hacer eso. Utilizar este:

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

Puede convertir un conjunto en un ArrayList, donde puede ordenar el ArrayListusoCollections.sort(List) .

Aquí está el código:

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

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

list.addAll(sortedset);

donde originalset = conjunto sin clasificar y list = la lista que se devolverá

@ Jeremy Stein Quería implementar el mismo código. Además, quería ordenar el conjunto de la lista, por lo que en lugar de usar el conjunto, convertí los valores del conjunto en Lista y clasifiqué esa lista por una variable. Este código me ayudó

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

Estoy usando este código, que me parece más práctico que la respuesta aceptada anteriormente:

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