Trier la Collection Java

La question est: "Trier la collection". Vous ne pouvez donc pas utiliser Collections.sort(List<T> l, Comparator<? super T> comparator).

Quelques conseils:

Pour le type de collection:

Comparator<String> defaultComparator = new Comparator<String>() {
   @Override
   public int compare(String o1, String o2) {
       return o1.compareTo(o2);
   }
};

Collection<String> collection = getSomeStringCollection();
String[] strings = collection.toArray(new String[collection.size()]);
Arrays.sort(strings, defaultComparator);
List<String> sortedStrings = Arrays.asList(strings);

Collection<String> collection = getSomeStringCollection();
List<String> list = new ArrayList(collection);
Collections.sort(list, defaultComparator);
collection = list; // if you wish

Pour le type de Liste:

List<String> list = getSomeStringList();
Collections.sort(list, defaultComparator);

Pour le type d'ensemble:

Set<String> set = getSomeStringSet();
// Than steps like in 'For Collection type' section or use java.util.TreeSet
// TreeSet sample:
// Sorted using java.lang.Comparable.
Set<String> naturalSorted = new TreeSet(set);

Set<String> set = getSomeStringSet();
Set<String> sortedSet = new TreeSet(defaultComparator);
sortedSet.addAll(set);

Version Java 8. Il y a java.util.List#sort(Comparator<? super E> c) méthode

List<String> list = getSomeStringList();
list.sort(defaultComparator);

Ou

List<String> list = getSomeStringList();
list.sort((String o1, String o2) -> o1.compareTo(o2));

Ou pour les types qui implémentent Comparable:

List<String> list = getSomeStringList();
list.sort(String::compareTo);

Un exemple légèrement différent dit si vous avez une classe qui n'implémente pas Comparable mais que vous voulez toujours la trier sur un champ ou une méthode.

Collections.sort(allMatching, new Comparator<ClassOne>() {
  @Override public int compare(final ClassOne o1, final ClassOne o2) {
    if (o1.getMethodToSort() > o2.getMethodToSort()) {
      return 1;
    } else if (o1.getMethodToSort() < o2.getMethodToSort()) {
      return -1;
    }  
    return 0;
  }
});

Vous devez implémenter l'interface Comparator.

Exemple:

public class CustomComparator implements Comparator<CustomObject> 
{
    @Override
    public int compare(CustomObject o1, CustomObject o2) {
        return o1.getId().compareTo(o2.getId());
    }
}

Ensuite, vous pouvez utiliser la méthode Collections classes Collections.sort():

Collections.sort(list, new CustomComparator());

Implémentez l'interfaceComparable sur votre customObject.

Comparator est le chemin

Voir Aussi

• le tri-de-arraylist

À partir de Java 8, vous pouvez maintenant le faire avec un flux en utilisant un lambda:

list.stream().sorted(Comparator.comparing(customObject::getId))
             .foreach(object -> System.out.println(object));

Utiliser tri.

Il Vous suffit de faire ceci:

Tous les éléments de la liste doivent implémenter l'interface comparable.

(Ou utilisez la version ci-dessous, comme d'autres l'ont déjà dit.)

Beaucoup de bonnes réponses, mais je n'ai pas trouvé celle-ci: Les collections ne peuvent pas être triées, vous ne pouvez que les parcourir.

Vous pouvez maintenant les parcourir et créer un nouveau something trié. Suivez les réponses ici pour cela.

Avec Java 8, vous avez plusieurs options, combinant des références de méthode et le comparateur intégré comparing:

import static java.util.Comparator.comparing;

Collection<CustomObject> list = new ArrayList<CustomObject>();

Collections.sort(list, comparing(CustomObject::getId));
//or
list.sort(comparing(CustomObject::getId));

SortedSet et Comparateur. Le comparateur doit respecter le champ id .

Vous pouvez utiliser la classe personnalisée java dans le but de trier.

Vous pouvez également utiliser:

Collections.sort(list, new Comparator<CustomObject>() {
    public int compare(CustomObject obj1, CustomObject obj2) {
        return obj1.id - obj2.id;
    }
});
System.out.println(list);