web-dev-qa-db-fra.com

Comparateur.comparant (...) d'un champ imbriqué

Supposons que j'ai un modèle de domaine comme celui-ci:

class Lecture {
     Course course;
     ... // getters
}

class Course {
     Teacher teacher;
     int studentSize;
     ... // getters
}

class Teacher {
     int age;
     ... // getters
}

Maintenant, je peux créer un comparateur d'enseignants comme celui-ci:

    return Comparator
            .comparing(Teacher::getAge);

Mais comment puis-je comparer Lecture sur des champs imbriqués, comme celui-ci?

    return Comparator
            .comparing(Lecture::getCourse::getTeacher:getAge) 
            .thenComparing(Lecture::getCourse::getStudentSize);

Je ne peux pas ajouter de méthode Lecture.getTeacherAge() sur le modèle.

javalambdajava-8comparator
15
Geoffrey De Smet

Vous ne pouvez pas imbriquer des références de méthodes. Vous pouvez utiliser des expressions lambda à la place:

return Comparator
        .comparing(l->l.getCourse().getTeacher().getAge(), Comparator.reverseOrder()) 
        .thenComparing(l->l.getCourse().getStudentSize());

Sans la nécessité d'un ordre inverse, c'est encore moins bavard:

return Comparator
        .comparing(l->l.getCourse().getTeacher().getAge()) 
        .thenComparing(l->l.getCourse().getStudentSize());

Remarque: dans certains cas, vous devez indiquer explicitement les types génériques. Par exemple, le code ci-dessous ne fonctionnera pas sans le <FlightAssignment, LocalDateTime> avant le comparing(...) dans Java 8.

flightAssignmentList.sort(Comparator
        .<FlightAssignment, LocalDateTime>comparing(a -> a.getFlight().getDepartureUTCDateTime())
        .thenComparing(a -> a.getFlight().getArrivalUTCDateTime())
        .thenComparing(FlightAssignment::getId));

Les versions plus récentes de Java ont une meilleure détection de type automatique et pourraient ne pas l'exiger.

24
Eran

Malheureusement, il n’existe pas de syntaxe Nice en Java pour cela. 

Si vous voulez réutiliser des parties du comparateur, je peux voir 2 façons:

  • en composant des comparateurs

    return comparing(Lecture::getCourse, comparing(Course::getTeacher, comparing(Teacher::getAge)))
       .thenComparing(Lecture::getCourse, comparing(Course::getStudentSize));

// or with separate comparators
Comparator<Teacher> byAge = comparing(Teacher::getAge);
Comparator<Course> byTeacherAge = comparing(Course::getTeacher, byAge);
Comparator<Course> byStudentsSize = comparing(Course::getStudentSize);
return comparing(Lecture::getCourse, byTeacherAge).thenComparing(Lecture::getCourse, byStudentsSize);

  • en composant les fonctions de lecture

    Function<Lecture, Course> getCourse = Lecture::getCourse;            
return comparing(getCourse.andThen(Course::getTeacher).andThen(Teacher::getAge))
       .thenComparing(getCourse.andThen(Course::getStudentSize));

// or with separate getters
Function<Lecture, Course> getCourse = Lecture::getCourse;
Function<Lecture, Integer> teacherAge = getCourse.andThen(Course::getTeacher).andThen(Teacher::getAge);
Function<Lecture, Integer> studentSize = getCourse.andThen(Course::getStudentSize);
return comparing(teacherAge).thenComparing(studentSize);
9
Nazarii Bardiuk
import Java.util.ArrayList;
import Java.util.Comparator;
import Java.util.List;
import Java.util.function.Function;

  class Person {
      String name ;
      PersonalDetail pDetail;
    public Person(String name, PersonalDetail pDetail) {
        super();
        this.name = name;
        this.pDetail = pDetail;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public PersonalDetail getpDetail() {
        return pDetail;
    }
    public void setpDetail(PersonalDetail pDetail) {
        this.pDetail = pDetail;
    }




  }

  class PersonalDetail{
      BirthDate birthDate;

    public BirthDate getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(BirthDate birthDate) {
        this.birthDate = birthDate;
    }

    public PersonalDetail(BirthDate birthDate) {
        super();
        this.birthDate = birthDate;
    }


  }

    class BirthDate {
        public String getBirthdate() {
            return birthdate;
        }

        public void setBirthdate(String birthdate) {
            this.birthdate = birthdate;
        }

    String birthdate;

        public BirthDate(String birthdate) {
            super();

            this.birthdate = birthdate;
        }  
  }

  public class Test1 {
       public static void main(String[] args) {
           BirthDate b1 = new BirthDate("2019-08-08");
           BirthDate b2 = new BirthDate("2025-09-09");
           BirthDate b3 = new BirthDate("2025-09-08");
           BirthDate b4 = new BirthDate("2024-09-08");

           PersonalDetail pd1  = new PersonalDetail(b1);
           PersonalDetail pd2  = new PersonalDetail(b2);
           PersonalDetail pd3  = new PersonalDetail(b3);
           PersonalDetail pd4  = new PersonalDetail(b4);

           Person p1  = new Person("P1",pd1);
           Person p2  = new Person("P2",pd2);
           Person p3  = new Person("P3",pd3);
           Person p4  = new Person("P4",pd4);

           List<Person> persons = new ArrayList();
           persons.add(p1);
           persons.add(p2);
           persons.add(p3);
           persons.add(p4);

           Function<Person, PersonalDetail> getCourse = Person::getpDetail;  

           Person minByAge = persons.stream()
                      .max(Comparator.comparing(getCourse.andThen(PersonalDetail::getBirthDate).andThen(BirthDate::getBirthdate))).get();


          System.out.println(maxByAge.getName());

       }

    }
0
manish garg