Trier ArrayList des objets personnalisés par propriété


1145

J'ai lu sur le tri des listes de tableaux à l'aide d'un comparateur, mais dans tous les exemples que les gens ont utilisés compareTo qui, selon certaines recherches, est une méthode pour les chaînes.

Je voulais trier une ArrayList d'objets personnalisés selon l'une de leurs propriétés: un objet Date ( getStartDay()). Normalement, je les compare par item1.getStartDate().before(item2.getStartDate())donc je me demandais si je pouvais écrire quelque chose comme:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}


2
La réponse de @Yishai dans ce post montre une utilisation élégante d'énumération pour le tri personnalisé et le tri groupé (plusieurs arguments) en utilisant le chaînage du comparateur.
gunalmel

Réponses:


1538

Depuis Dateimplémente Comparable, il a une compareTométhode commeString fait.

Ainsi, votre coutume Comparatorpourrait ressembler à ceci:

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

La compare()méthode doit renvoyer un int, vous ne pouvez donc pas retourner directement unboolean comme vous l'aviez prévu de toute façon.

Votre code de tri serait à peu près comme vous l'avez écrit:

Collections.sort(Database.arrayList, new CustomComparator());

Une manière légèrement plus courte d'écrire tout cela, si vous n'avez pas besoin de réutiliser votre comparateur, est de l'écrire en tant que classe anonyme en ligne:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Depuis

Vous pouvez maintenant écrire le dernier exemple sous une forme plus courte en utilisant une expression lambda pour Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Et Lista une sort(Comparator)méthode, vous pouvez donc raccourcir encore plus:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

C'est un idiome si courant qu'il existe une méthode intégrée pour générer un Comparatorpour une classe avec une Comparableclé:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Tous ces éléments sont des formes équivalentes.


33
+1 pour avoir mentionné qu'il devrait revenir intet que vous feriez mieux d'utiliser Date#compareTo()pour cela. Pourquoi ce n'est pas voté au-dessus de l'autre réponse me dépasse. Ce lien peut également être utile: Tutoriel de commande d'objets sur Sun.com .
BalusC

5
Je pense que la meilleure réponse devrait également inclure la bonne façon de le faire dans Java 8. Collections.sort (list, Comparator.comparing (MyObject :: getStartDate)); qui lit mieux et est moins sujet aux erreurs. Il est très facile d'écrire return o1.getStartDate (). CompareTo (o1.getStartDate ());
Kuba

2
La classe de comparaison doit être statique :)
Jarmez De La Rocha

4
@Kuba mieux encore, utilisez List.sort().
shmosel

3
Cette solution ne fonctionne pas sur l'API Android <24. Connaissez-vous une solution pour cela?
Jim Clermonts

194

Les classes qui ont un ordre de tri naturel (un numéro de classe, par exemple) doivent implémenter l'interface Comparable, tandis que les classes qui n'ont pas d'ordre de tri naturel (un président de classe, par exemple) doivent être fournies avec un comparateur (ou un comparateur anonyme) classe).

Deux exemples:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Usage:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

J'ai essayé - mais quand je veux accéder à la classe de comparaison ChairWeightComparator à l'extérieur dans n'importe quelle autre classe, je n'ai pas accès à cette classe (bien sûr que ce n'est pas public car elle n'est pas publique). Dois-je créer une nouvelle classe publique ChairWeightComparator dans un fichier séparé? - suis-je vraiment le premier à essayer ça après 3 ans ou ai-je raté qch?
user387184

@ user387184 - rendez-le simplement public et placez-le dans son propre fichier (de préférence son propre package également) et vous pourrez l'utiliser partout dans votre projet. Pas besoin de créer une classe supplémentaire!
Björn

vous voulez dire créer un nouveau fichier - pas une classe et mettre le code: "class ChairWeightComparator implements Comparator <Chair> {...."?
user387184

@ user387184, exactement - mais avec le mot clé publicdevant class.
Björn

157

Pour trier un, ArrayListvous pouvez utiliser l'extrait de code suivant:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

1
Quiconque utilise lambda stackoverflow.com/questions/2784514/…
Trieur

Cela trie mais donne une valeur double pour chaque élément
Sam

44

Oui, vous pouvez. Il existe deux options de comparaison des éléments, l' interface Comparable et l' interface Comparateur .

Ces deux interfaces permettent un comportement différent. Comparable vous permet de faire en sorte que l'objet agisse comme vous venez de décrire Strings (en fait, String implémente Comparable). Le second, Comparateur, vous permet de faire ce que vous demandez de faire. Vous le feriez comme ceci:

Collections.sort(myArrayList, new MyComparator());

Cela entraînera la méthode Collections.sort à utiliser votre comparateur pour son mécanisme de tri. Si les objets dans ArrayList implémentent des éléments comparables, vous pouvez à la place faire quelque chose comme ceci:

Collections.sort(myArrayList);

La classe Collections contient un certain nombre de ces outils communs utiles.


42

Expression lambda JAVA 8

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

OU

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

3
OuCollections.sort(studList, Comparator.comparing(Student::getFirstName));
Holger

5
.. oustudList.sort(Comparator.comparing(Student::getFirstName));
Alexis C.

L'ordre de tri sera toujours croissant dans votre cas. J'ai également pris soin de l'ordre de tri dans mon exemple. Merci messieurs.
Sorter

33

Avec Java 8, vous pouvez utiliser une référence de méthode pour votre comparateur:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

@ user387184 malheureusement, android ne prend pas en charge Java 8, bien qu'il puisse y avoir une solution (je ne l'ai pas testé).
assylias

14

Comme les technologies apparaissent tous les jours, la réponse changera dans le temps. J'ai jeté un œil à LambdaJ et semble très intéressant.

Vous pouvez essayer de résoudre ces tâches avec LambdaJ . Vous pouvez le trouver ici: http://code.google.com/p/lambdaj/

Voici un exemple:

Tri itératif

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Trier avec lambda

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Bien sûr, ce type de beauté a un impact sur les performances (en moyenne 2 fois), mais pouvez-vous trouver un code plus lisible?


Cela trie mais donne une valeur double pour chaque élément comment l'éviter
Sam

@Sam, ça ne devrait pas ... ça fonctionne comme prévu. A moins que vous n'utilisiez une nouvelle version avec un bug, que je vous recommande de poster sur le forum. Quoi qu'il en soit, cette réponse a été postée avant java 8, si vous l'utilisez, alors ce sera beaucoup mieux que d'utiliser lambdaj
Federico Piazza

J'ai dû supprimer même les éléments dans une boucle foreach autrement, cela me donne le double de chaque contenu.
Sam

13
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}

7
Bienvenue sur stackoverflow. Cette question a reçu une réponse il y a quelque temps. Avant de ressusciter d'anciens threads, assurez-vous que votre réponse ajoute quelque chose d'important au thread.
Leigh

1
Veuillez ajouter une explication à votre réponse.
Arashsoft

Compilez et exécutez. Le code est le commentaire et l'explication.
CharlesW

9

Le meilleur moyen simple avec JAVA 8 est le tri alphabétique anglais

Implémentation de classe

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Trier

  Collections.sort(Your List);

Si vous souhaitez trier pour un alphabet contenant des caractères non anglais, vous pouvez utiliser les paramètres régionaux ... Sous le code, utilisez le tri des caractères turcs ...

Implémentation de classe

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Trier

Collections.sort(your array list,new NewspaperClass());

9

Référence des fonctions et des méthodes

La Collections.sortméthode peut trier un en Listutilisant un que Comparatorvous passez. Cela Comparatorpeut être implémenté en utilisant la Comparator.comparingméthode où vous pouvez passer une référence de méthode comme nécessaireFunction . Heureusement, le code réel est beaucoup plus simple et plus court que cette description.

Pour Java 8:

Collections.sort(list, comparing(ClassName::getName));

ou

Collections.sort(list, comparing(ClassName::getName).reversed());

Une autre façon est

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

1
L'appel nécessite le niveau API 24
akshay bhange


6

Java 8 Lambda raccourcit le tri.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

2
Collections.sort(stdList, Comparator.comparing(SomeClass::getName));
bcsb1001


5

Oui, c'est possible par exemple dans cette réponse je trie par la propriété vde la classeIndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Si vous remarquez ici, je crée une classe interne anonyme (qui est le Java pour les fermetures) et je la transmets directement à la sortméthode de la classeArrays

Votre objet peut également implémenter Comparable(c'est ce que fait String et la plupart des bibliothèques de base de Java), mais cela définirait "l'ordre de tri naturel" de la classe elle-même, et ne vous permet pas d'en insérer de nouvelles.


1
... mais que vous pouvez simplement remplacer Comparator:)
BalusC

5

J'ai trouvé la plupart sinon toutes ces réponses reposent sur la classe sous-jacente (Object) pour implémenter comparable ou pour avoir une interface comparable d'assistance.

Pas avec ma solution! Le code suivant vous permet de comparer le champ d'un objet en connaissant son nom de chaîne. Vous pouvez facilement le modifier pour ne pas utiliser le nom, mais vous devez ensuite l'exposer ou construire l'un des objets que vous souhaitez comparer.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}

5

Vous pouvez essayer la commande de goyave :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

5

Vous pouvez trier à l'aide de java 8

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

3

Ces extraits de code peuvent être utiles. Si vous voulez trier un objet dans mon cas, je veux trier par VolumeName:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Cela marche. Je l'utilise dans mon jsp.


3

Avec cette bibliothèque ici, vous pouvez trier la liste des objets personnalisés sur plusieurs colonnes. La bibliothèque utilise les fonctionnalités de la version 8.0. Un échantillon y est également disponible. Voici un exemple à faire

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);

3

Vous pouvez jeter un œil à cette présentation au Java Forum de Stuttgart en Allemagne en 2016.

Seules quelques diapositives utilisent la langue allemande, 99% du contenu est du code source Java "basé sur l'anglais"; comme

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

OurCustomComparator utilise des méthodes par défaut (et d'autres idées intéressantes). Comme indiqué, conduisant à un code très concis pour choisir une méthode getter pour le tri; et enchaînement (ou inversion) super simple des critères de tri.

Si vous aimez java8, vous y trouverez beaucoup de matériel pour vous aider à démarrer.


3

Nouveau depuis 1.8 est une méthode List.sort () au lieu d'utiliser Collection.sort (), donc vous appelez directement mylistcontainer.sort ()

Voici un extrait de code qui illustre la fonctionnalité List.sort ():

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

La classe Fruit est:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   


1

Je préfère ce processus:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Si votre liste d'objets a une propriété appelée startDate, vous appelez cette fonction encore et encore. Vous pouvez même les enchaîner startDate.time.

Cela nécessite votre objet à Comparablequi signifie que vous avez besoin d' une compareTo, equalset la hashCodemise en œuvre.

Oui, cela pourrait être plus rapide ... Mais maintenant, vous n'avez plus besoin de faire un nouveau comparateur pour chaque type de tri. Si vous pouvez économiser du temps de développement et renoncer à l'exécution, vous pouvez opter pour celui-ci.


3
1, cette réponse a été donnée 2 heures plus tôt avec le code de travail fourni également. Il n'est pas nécessaire de republier la même solution et d'encombrer le forum, d'autant plus que BeanComparator n'est pas une classe standard, donc ce n'est pas vraiment une solution si l'affiche ne sait pas de quoi vous parlez. Si vous aimez la suggestion originale, vous pouvez la voter et ajouter un commentaire si vous le souhaitez.
camickr

0

À l'aide de Java 8, l'utilisation peut définir le Comparatorsur une seule ligne en utilisantComparator.comparing()

Utilisez l'une des méthodes suivantes:

Option 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Option 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));

1
Semble être un double de cette réponse datant de 3 ans.
Basil Bourque

1
Pas exactement, seule l'option 2 ici est similaire à l'option 1 dans la réponse mentionnée. Je pense que deux réponses différentes peuvent avoir au moins quelques similitudes si elles répondent à la même question.
Sahil Chhabra

0

Votre classe personnalisée peut implémenter l'interface "Comparable", qui nécessite une implémentation de la méthode CompareTo. Dans la méthode CompareTo, vous pouvez ensuite définir ce que signifie qu’un objet est inférieur ou supérieur à l'autre objet. Donc, dans votre exemple, cela peut ressembler à ceci:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

Un nombre négatif indique que cette c'est plus petite que l'objet en cours par rapport à. Un nombre positif indique que c'est plus grand que le rapport à l' objet et un moyen de zéro que les objets sont égaux.

Vous pouvez ensuite utiliser collections.sort (myList) pour trier votre liste sans avoir à alimenter un comparateur. Cette méthode présente également l'avantage de trier automatiquement les éléments si vous utilisez des structures de données de collection triées comme un TreeSet ou un TreeMap.

Vous pouvez consulter cet article si vous souhaitez en savoir plus sur l'interface comparable (divulgation: je suis l'auteur;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/


0

Vous pouvez également utiliser Springs PropertyComparator si vous n'avez qu'un chemin de propriété String vers la propriété (imbriquée) que vous souhaitez trier:

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

L'inconvénient est que ce comparateur ignore silencieusement les propriétés qui n'existent pas ou ne sont pas accessibles et les traite comme une valeur nulle pour la comparaison. Cela signifie que vous devez soigneusement tester un tel comparateur ou valider d'une manière ou d'une autre l'existence du chemin de propriété.


0

en utilisant l'api java-8 stream, vous pouvez trier un ArrayListpar:

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.