Wie sortiere ich einen Satz in einer Liste in Java?

In Java habe ich eine Set, und ich möchte daraus eine sortierte machen List. Gibt es eine Methode im java.util.CollectionsPaket, die dies für mich erledigt?

Die Antwort des OP ist nicht die beste. Es ist ineffizient, da es ein neues List und ein unnötiges neues Array erstellt. Außerdem werden "ungeprüfte" Warnungen aufgrund von Typensicherheitsproblemen bei generischen Arrays ausgegeben.

Verwenden Sie stattdessen Folgendes:

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

Hier ist ein Anwendungsbeispiel:

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

Sortiertes Set:

return new TreeSet(setIWantSorted);

oder:

return new ArrayList(new TreeSet(setIWantSorted));

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

… Sollte jedoch den Trick machen. Fügen Sie gegebenenfalls mit Generika Geschmack hinzu.

So können Sie es mit den Streams von Java 8 machen:

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

oder mit einem benutzerdefinierten Komparator:

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

Es ist immer sicher, entweder die Comparator- oder die Comparable-Schnittstelle zu verwenden, um eine Sortierimplementierung bereitzustellen (wenn das Objekt keine String- oder Wrapper-Klasse für primitive Datentypen ist). Als Beispiel für eine Komparatorimplementierung zum Sortieren von Mitarbeitern nach Namen

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

Der Komparator ist nützlich, wenn Sie einen unterschiedlichen Sortieralgorithmus für dasselbe Objekt benötigen (z. B. Emp-Name, Emp-Gehalt usw.). Die Single-Mode-Sortierung kann mithilfe der vergleichbaren Schnittstelle für das gewünschte Objekt implementiert werden.

Es gibt keine einzige Methode, um das zu tun. Benutze das:

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

Sie können ein Set in ein konvertieren, in ArrayListdem Sie die ArrayListVerwendung sortieren können Collections.sort(List).

Hier ist der Code:

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

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

list.addAll(sortedset);

Dabei ist Originalset = unsortierte Menge und Liste = die zurückzugebende Liste

@ Jeremy Stein Ich wollte den gleichen Code implementieren. Außerdem wollte ich das Set nach Liste sortieren. Anstatt Set zu verwenden, habe ich Set-Werte in List konvertiert und diese Liste nach der Variablen sortiert. Dieser Code hat mir geholfen,

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

Ich verwende diesen Code, den ich praktischer finde als die oben akzeptierte Antwort:

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