Comment trier un ensemble dans une liste en Java?

En Java, j'ai un Set, et je veux le transformer en un fichier trié List. Y a-t-il une méthode dans le java.util.Collectionspackage qui fera cela pour moi?

La réponse fournie par le PO n'est pas la meilleure. Il est inefficace, car il crée un nouveau tableau List et un nouveau tableau inutile. En outre, il déclenche des avertissements «non contrôlés» en raison des problèmes de sécurité de type autour des tableaux génériques.

À la place, utilisez quelque chose comme ceci:

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

Voici un exemple d'utilisation:

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

Ensemble trié:

return new TreeSet(setIWantSorted);

ou:

return new ArrayList(new TreeSet(setIWantSorted));

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

… Devrait faire l'affaire cependant. Ajoutez de la saveur avec des génériques, le cas échéant.

Voici comment vous pouvez le faire avec les flux de Java 8:

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

ou avec un comparateur personnalisé:

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

Utilisez toujours en toute sécurité l'interface Comparator ou Comparable pour fournir une implémentation de tri (si l'objet n'est pas une classe String ou Wrapper pour les types de données primitifs). Comme exemple d'implémentation d'un comparateur pour trier les employés en fonction du nom

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

Le comparateur est utile lorsque vous avez besoin d'un algorithme de tri différent sur le même objet (Dites le nom de l'emp, le salaire de l'emp, etc.). Le tri en mode unique peut être implémenté à l'aide de l'interface Comparable dans l'objet requis.

Il n'y a pas de méthode unique pour faire cela. Utilisez ceci:

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

Vous pouvez convertir un ensemble en un ArrayList, où vous pouvez trier l' ArrayListutilisation Collections.sort(List).

Voici le code:

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

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

list.addAll(sortedset);

où originalset = ensemble non trié et liste = la liste à renvoyer

@Jeremy Stein Je voulais implémenter le même code. De plus, je voulais trier l'ensemble en liste, donc au lieu d'utiliser Set, j'ai converti les valeurs d'ensemble en liste et trier cette liste en fonction de sa variable. Ce code m'a aidé,

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

J'utilise ce code, que je trouve plus pratique que la réponse acceptée ci-dessus:

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