How to compare objects by multiple fields

Question

Assume you have some objects which have several fields they can be compared by   public class Person        private String firstName      private String lastName      private String age          Constructors            Methods         So in this example  when you ask if   a compareTo b   gt  0   you might be asking if a s last name comes before b s  or if a is older than b  etc     What is the cleanest way to enable multiple comparison between these kinds of objects without adding unnecessary clutter or overhead    java lang Comparable interface allows comparison by one field only Adding numerous compare methods  i e  compareByFirstName    compareByAge    etc     is cluttered in my opinion    So what is the best way to go about this

User · Answer

Usually I override my compareTo   method like this whenever I have to do multilevel sorting   public int compareTo Song o           TODO Auto-generated method stub     int comp1   10000000  movie compareTo o movie   1000  artist compareTo o artist   songLength      int comp2   10000000  o movie compareTo movie   1000  o artist compareTo artist   o songLength      return comp1-comp2       Here first preference is given to movie name then to artist and lastly to songLength  You just have to make sure that those multipliers are distant enough to not cross each other s boundaries

User · Answer

You can also have a look at Enum that implements Comparator   http   tobega blogspot com 2008 05 beautiful-enums html  e g   Collections sort myChildren  Child Order ByAge descending

User · Answer

from Ways to sort lists of objects in Java based on multiple fields   Working code in this gist  Using Java 8 lambda s  added April 10  2019   Java 8 solves this nicely by lambda s  though Guava and Apache Commons might still offer more flexibility    Collections sort reportList  Comparator comparing Report  getReportKey               thenComparing Report  getStudentNumber               thenComparing Report  getSchool      Thanks to  gaoagong s answer below   Messy and convoluted  Sorting by hand  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              int sizeCmp   p1 size compareTo p2 size             if  sizeCmp    0                  return sizeCmp                        int nrOfToppingsCmp   p1 nrOfToppings compareTo p2 nrOfToppings             if  nrOfToppingsCmp    0                  return nrOfToppingsCmp                        return p1 name compareTo p2 name                     This requires a lot of typing  maintenance and is error prone   The reflective way  Sorting with BeanComparator  ComparatorChain chain   new ComparatorChain Arrays asList     new BeanComparator  size        new BeanComparator  nrOfToppings        new BeanComparator  name       Collections sort pizzas  chain       Obviously this is more concise  but even more error prone as you lose your direct reference to the fields by using Strings instead  no typesafety  auto-refactorings   Now if a field is renamed  the compiler won   t even report a problem  Moreover  because this solution uses reflection  the sorting is much slower   Getting there  Sorting with Google Guava   s ComparisonChain  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              return ComparisonChain start   compare p1 size  p2 size  compare p1 nrOfToppings  p2 nrOfToppings  compare p1 name  p2 name  result                 or in case the fields can be null                        return ComparisonChain start                compare p1 size  p2 size  Ordering natural   nullsLast                 compare p1 nrOfToppings  p2 nrOfToppings  Ordering natural   nullsLast                 compare p1 name  p2 name  Ordering natural   nullsLast                 result                                  This is much better  but requires some boiler plate code for the most common use case  null-values should be valued less by default  For null-fields  you have to provide an extra directive to Guava what to do in that case  This is a flexible mechanism if you want to do something specific  but often you want the default case  ie  1  a  b  z  null    Sorting with Apache Commons CompareToBuilder  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              return new CompareToBuilder   append p1 size  p2 size  append p1 nrOfToppings  p2 nrOfToppings  append p1 name  p2 name  toComparison                      Like Guava   s ComparisonChain  this library class sorts easily on multiple fields  but also defines default behavior for null values  ie  1  a  b  z  null   However  you can   t specify anything else either  unless you provide your own Comparator   Thus  Ultimately it comes down to flavor and the need for flexibility  Guava   s ComparisonChain  vs  concise code  Apache   s CompareToBuilder    Bonus method  I found a nice solution that combines multiple comparators in order of priority on CodeReview in a MultiComparator   class MultiComparator lt T gt  implements Comparator lt T gt        private final List lt Comparator lt T gt  gt  comparators       public MultiComparator List lt Comparator lt   super T gt  gt  comparators            this comparators   comparators             public MultiComparator Comparator lt   super T gt     comparators            this Arrays asList comparators               public int compare T o1  T o2            for  Comparator lt T gt  c   comparators                int result   c compare o1  o2               if  result    0                    return result                                  return 0             public static  lt T gt  void sort List lt T gt  list  Comparator lt   super T gt     comparators            Collections sort list  new MultiComparator lt T gt  comparators              Ofcourse Apache Commons Collections has a util for this already   ComparatorUtils chainedComparator comparatorCollection   Collections sort list  ComparatorUtils chainedComparator comparators

User · Answer

Starting from Steve s answer the ternary operator can be used   public int compareTo Person other        int f   firstName compareTo other firstName       int l   lastName compareTo other lastName       return f    0   f   l    0   l   Integer compare age  other age

User · Answer

You can implement a Comparator which compares two Person objects  and you can examine as many of the fields as you like  You can put in a variable in your comparator that tells it which field to compare to  although it would probably be simpler to just write multiple comparators

User · Answer

Another option you can always consider is Apache Commons  It provides a lot of options   import org apache commons lang3 builder CompareToBuilder    Ex   public int compare Person a  Person b       return new CompareToBuilder         append a getName    b getName          append a getAddress    b getAddress          toComparison

User · Answer

here threshold buyRange targetPercentage are three keys on that i have sorted my arraylist  final Comparator lt BasicDBObject gt        sortOrder   new Comparator lt BasicDBObject gt                          public int compare BasicDBObject e1  BasicDBObject e2                            int threshold   new Double e1 getDouble  threshold                             compareTo new Double e2 getDouble  threshold                              if  threshold    0                              return threshold                           int buyRange   new Double e1 getDouble  buyRange                             compareTo new Double e2 getDouble  buyRange                              if  buyRange    0                              return buyRange                           return  new Double e1 getDouble  targetPercentage     lt  new Double                                  e2 getDouble  targetPercentage      -1    new Double                                          e1 getDouble  targetPercentage       new Double                                                  e2 getDouble  targetPercentage      0   1                                                             Collections sort objectList  sortOrder

User · Answer

Better late than never - if you re looking for unnecessary clutter or overhead then it s hard to beat the following in terms of least code fast execution at the same time  Data class  public class MyData       int id      boolean relevant      String name      float value     Comparator  public class MultiFieldComparator implements Comparator lt MyData gt         Override     public int compare MyData dataA  MyData dataB            int result          if  result   Integer compare dataA id  dataB id      0  amp  amp              result   Boolean compare dataA relevant  dataB relevant      0  amp  amp              result   dataA name compareTo dataB name      0              result   Float compare dataA value  dataB value           return result           If you are just looking to sort a collection by a custom order then the following is even cleaner  myDataList sort  dataA  dataB  - gt        int result      if  result   Integer compare dataA id  dataB id      0  amp  amp          result   Boolean compare dataA relevant  dataB relevant      0  amp  amp          result   dataA name compareTo dataB name      0          result   Float compare dataA value  dataB value       return result

User · Answer

Following blog given good chained Comparator example   http   www codejava net java-core collections sorting-a-list-by-multiple-attributes-example  import java util Arrays  import java util Comparator  import java util List          This is a chained comparator that is used to sort a list by multiple    attributes by chaining a sequence of comparators of individual fields    together         public class EmployeeChainedComparator implements Comparator lt Employee gt         private List lt Comparator lt Employee gt  gt  listComparators        SafeVarargs     public EmployeeChainedComparator Comparator lt Employee gt     comparators            this listComparators   Arrays asList comparators               Override     public int compare Employee emp1  Employee emp2            for  Comparator lt Employee gt  comparator   listComparators                int result   comparator compare emp1  emp2               if  result    0                    return result                                  return 0            Calling Comparator   Collections sort listEmployees  new EmployeeChainedComparator                  new EmployeeJobTitleComparator                    new EmployeeAgeComparator                    new EmployeeSalaryComparator

User · Answer

Instead of comparison methods you may want to just define several types of  Comparator  subclasses inside the Person class   That way you can pass them into standard Collections sorting methods

User · Answer

I think it d be more confusing if your comparison algorithm were  clever   I d go with the numerous comparison methods you suggested   The only exception for me would be equality  For unit testing  it s been useful to me to override the  Equals  in  net  in order to determine if several fields are equal between two objects  and not that the references are equal

User · Answer

Following is the example in jdk 1 8 package com  import java util ArrayList  import java util Comparator  import java util List   class User       private String firstName      private String lastName      private Integer age       public Integer getAge             return age             public User setAge Integer age            this age   age          return this             public String getFirstName             return firstName             public User setFirstName String firstName            this firstName   firstName          return this             public String getLastName             return lastName             public User setLastName String lastName            this lastName   lastName          return this            public class MultiFieldsComparision        public static void main String   args            List lt User gt  users   new ArrayList lt User gt              User u1   new User   setFirstName  Pawan   setLastName  Singh   setAge 38           User u2   new User   setFirstName  Pawan   setLastName  Payal   setAge 37           User u3   new User   setFirstName  Anuj   setLastName  Kumar   setAge 60           User u4   new User   setFirstName  Anuj   setLastName  Kumar   setAge 43           User u5   new User   setFirstName  Pawan   setLastName  Chamoli   setAge 44           User u6   new User   setFirstName  Pawan   setLastName  Singh   setAge 5            users add u1           users add u2           users add u3           users add u4           users add u5           users add u6            System out println         Before Sorting                    users forEach user - gt                System out println user getFirstName             user getLastName             user getAge                          System out println         Aftre Sorting                    users sort                  Comparator comparing User  getFirstName  thenComparing User  getLastName  thenComparing User  getAge             users forEach user - gt                System out println user getFirstName             user getLastName             user getAge

User · Answer

Writing a Comparator manually for such an use case is a terrible solution IMO  Such ad hoc approaches have many drawbacks     No code reuse  Violates DRY  Boilerplate  Increased possibility of errors      So what s the solution   First some theory   Let us denote the proposition  type A supports comparison  by Ord A   From program perspective  you can think of Ord A as an object containing logic for comparing two As  Yes  just like Comparator     Now  if Ord A and Ord B  then their composite  A  B  should also support comparison  i e  Ord  A  B   If Ord A  Ord B  and Ord C  then Ord  A  B  C     We can extend this argument to arbitrary arity  and say   Ord A  Ord B  Ord C       Ord Z   Ord  A  B  C      Z   Let s call this statement 1   The comparison of the composites will work just as you described in your question  the first comparison will be tried first  then the next one  then the next  and so on   That s the first part of our solution  Now the second part   If you know that Ord A  and know how to transform B to A  call that transformation function f   then you can also have Ord B   How  Well  when the two B instances are to be compared   you first transform them to A using f and then apply Ord A   Here  we are mapping the transformation B   A to Ord A   Ord B  This is known as contravariant mapping  or comap for short    Ord A   B   A   comap Ord B  Let s call this statement 2     Now let s apply this to your example    You have a data type named Person that comprises three fields of type String     We know that Ord String  By statement 1  Ord  String  String  String    We can easily write a function from Person to  String  String  String    Just return the three fields    Since we know Ord  String  String  String  and Person    String  String  String   by statement 2  we can use comap to get Ord Person     QED     How do I implement all these concepts   The good news is you don t have to  There already exists a library which implements all the ideas described in this post   If you are curious how these are implemented  you can look under the hood    This is how the code will look with it   Ord lt Person gt  personOrd     p3Ord stringOrd  stringOrd  stringOrd  comap     new F lt Person  P3 lt String  String  String gt  gt           public P3 lt String  String  String gt  f Person x           return p x getFirstName    x getLastname    x getAge                       Explanation    stringOrd is an object of type Ord lt String gt   This corresponds to our original  supports comparison  proposition  p3Ord is a method that takes Ord lt A gt   Ord lt B gt   Ord lt C gt   and returns Ord lt P3 lt A  B  C gt  gt   This corresponds to statement 1   P3 stands for product with three elements  Product is an algebraic term for composites   comap corresponds to well  comap  F lt A  B gt  represents a transformation function A   B  p is a factory method for creating products  The whole expression corresponds to statement 2    Hope that helps

User · Answer

If you implement the Comparable interface  you ll want to choose one simple property to order by  This is known as natural ordering  Think of it as the default  It s always used when no specific comparator is supplied  Usually this is name  but your use case may call for something different  You are free to use any number of other Comparators you can supply to various collections APIs to override the natural ordering   Also note that typically if a compareTo b     0  then a equals b     true  It s ok if not but there are side effects to be aware of  See the excellent javadocs on the Comparable interface and you ll find lots of great information on this

User · Answer

here threshold buyRange targetPercentage are three keys on that i have sorted my arraylist  final Comparator lt BasicDBObject gt        sortOrder   new Comparator lt BasicDBObject gt                          public int compare BasicDBObject e1  BasicDBObject e2                            int threshold   new Double e1 getDouble  threshold                             compareTo new Double e2 getDouble  threshold                              if  threshold    0                              return threshold                           int buyRange   new Double e1 getDouble  buyRange                             compareTo new Double e2 getDouble  buyRange                              if  buyRange    0                              return buyRange                           return  new Double e1 getDouble  targetPercentage     lt  new Double                                  e2 getDouble  targetPercentage      -1    new Double                                          e1 getDouble  targetPercentage       new Double                                                  e2 getDouble  targetPercentage      0   1                                                             Collections sort objectList  sortOrder

User · Answer

With Java 8    Comparator comparing  Person p - gt p firstName             thenComparing p- gt p lastName             thenComparingInt p- gt p age     If you have accessor methods   Comparator comparing Person  getFirstName             thenComparing Person  getLastName             thenComparingInt Person  getAge     If a class implements Comparable then such comparator may be used in compareTo method    Override public int compareTo Person o       return Comparator comparing Person  getFirstName                 thenComparing Person  getLastName                 thenComparingInt Person  getAge                 compare this  o

User · Answer

If there are multiple ways a user might order person  you could also have multiple Comparators setup as constants somewhere  Most of the sort operations and sorted collections take a comparator as a parameter

User · Answer

You can also have a look at Enum that implements Comparator   http   tobega blogspot com 2008 05 beautiful-enums html  e g   Collections sort myChildren  Child Order ByAge descending

User · Answer

Instead of comparison methods you may want to just define several types of  Comparator  subclasses inside the Person class   That way you can pass them into standard Collections sorting methods

User · Answer

Better late than never - if you re looking for unnecessary clutter or overhead then it s hard to beat the following in terms of least code fast execution at the same time  Data class  public class MyData       int id      boolean relevant      String name      float value     Comparator  public class MultiFieldComparator implements Comparator lt MyData gt         Override     public int compare MyData dataA  MyData dataB            int result          if  result   Integer compare dataA id  dataB id      0  amp  amp              result   Boolean compare dataA relevant  dataB relevant      0  amp  amp              result   dataA name compareTo dataB name      0              result   Float compare dataA value  dataB value           return result           If you are just looking to sort a collection by a custom order then the following is even cleaner  myDataList sort  dataA  dataB  - gt        int result      if  result   Integer compare dataA id  dataB id      0  amp  amp          result   Boolean compare dataA relevant  dataB relevant      0  amp  amp          result   dataA name compareTo dataB name      0          result   Float compare dataA value  dataB value       return result

User · Answer

You can implement a Comparator which compares two Person objects  and you can examine as many of the fields as you like  You can put in a variable in your comparator that tells it which field to compare to  although it would probably be simpler to just write multiple comparators

User · Answer

Starting from Steve s answer the ternary operator can be used   public int compareTo Person other        int f   firstName compareTo other firstName       int l   lastName compareTo other lastName       return f    0   f   l    0   l   Integer compare age  other age

User · Answer

Usually I override my compareTo   method like this whenever I have to do multilevel sorting   public int compareTo Song o           TODO Auto-generated method stub     int comp1   10000000  movie compareTo o movie   1000  artist compareTo o artist   songLength      int comp2   10000000  o movie compareTo movie   1000  o artist compareTo artist   o songLength      return comp1-comp2       Here first preference is given to movie name then to artist and lastly to songLength  You just have to make sure that those multipliers are distant enough to not cross each other s boundaries

User · Answer

If you implement the Comparable interface  you ll want to choose one simple property to order by  This is known as natural ordering  Think of it as the default  It s always used when no specific comparator is supplied  Usually this is name  but your use case may call for something different  You are free to use any number of other Comparators you can supply to various collections APIs to override the natural ordering   Also note that typically if a compareTo b     0  then a equals b     true  It s ok if not but there are side effects to be aware of  See the excellent javadocs on the Comparable interface and you ll find lots of great information on this

User · Answer

from Ways to sort lists of objects in Java based on multiple fields   Working code in this gist  Using Java 8 lambda s  added April 10  2019   Java 8 solves this nicely by lambda s  though Guava and Apache Commons might still offer more flexibility    Collections sort reportList  Comparator comparing Report  getReportKey               thenComparing Report  getStudentNumber               thenComparing Report  getSchool      Thanks to  gaoagong s answer below   Messy and convoluted  Sorting by hand  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              int sizeCmp   p1 size compareTo p2 size             if  sizeCmp    0                  return sizeCmp                        int nrOfToppingsCmp   p1 nrOfToppings compareTo p2 nrOfToppings             if  nrOfToppingsCmp    0                  return nrOfToppingsCmp                        return p1 name compareTo p2 name                     This requires a lot of typing  maintenance and is error prone   The reflective way  Sorting with BeanComparator  ComparatorChain chain   new ComparatorChain Arrays asList     new BeanComparator  size        new BeanComparator  nrOfToppings        new BeanComparator  name       Collections sort pizzas  chain       Obviously this is more concise  but even more error prone as you lose your direct reference to the fields by using Strings instead  no typesafety  auto-refactorings   Now if a field is renamed  the compiler won   t even report a problem  Moreover  because this solution uses reflection  the sorting is much slower   Getting there  Sorting with Google Guava   s ComparisonChain  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              return ComparisonChain start   compare p1 size  p2 size  compare p1 nrOfToppings  p2 nrOfToppings  compare p1 name  p2 name  result                 or in case the fields can be null                        return ComparisonChain start                compare p1 size  p2 size  Ordering natural   nullsLast                 compare p1 nrOfToppings  p2 nrOfToppings  Ordering natural   nullsLast                 compare p1 name  p2 name  Ordering natural   nullsLast                 result                                  This is much better  but requires some boiler plate code for the most common use case  null-values should be valued less by default  For null-fields  you have to provide an extra directive to Guava what to do in that case  This is a flexible mechanism if you want to do something specific  but often you want the default case  ie  1  a  b  z  null    Sorting with Apache Commons CompareToBuilder  Collections sort pizzas  new Comparator lt Pizza gt             Override       public int compare Pizza p1  Pizza p2              return new CompareToBuilder   append p1 size  p2 size  append p1 nrOfToppings  p2 nrOfToppings  append p1 name  p2 name  toComparison                      Like Guava   s ComparisonChain  this library class sorts easily on multiple fields  but also defines default behavior for null values  ie  1  a  b  z  null   However  you can   t specify anything else either  unless you provide your own Comparator   Thus  Ultimately it comes down to flavor and the need for flexibility  Guava   s ComparisonChain  vs  concise code  Apache   s CompareToBuilder    Bonus method  I found a nice solution that combines multiple comparators in order of priority on CodeReview in a MultiComparator   class MultiComparator lt T gt  implements Comparator lt T gt        private final List lt Comparator lt T gt  gt  comparators       public MultiComparator List lt Comparator lt   super T gt  gt  comparators            this comparators   comparators             public MultiComparator Comparator lt   super T gt     comparators            this Arrays asList comparators               public int compare T o1  T o2            for  Comparator lt T gt  c   comparators                int result   c compare o1  o2               if  result    0                    return result                                  return 0             public static  lt T gt  void sort List lt T gt  list  Comparator lt   super T gt     comparators            Collections sort list  new MultiComparator lt T gt  comparators              Ofcourse Apache Commons Collections has a util for this already   ComparatorUtils chainedComparator comparatorCollection   Collections sort list  ComparatorUtils chainedComparator comparators

User · Answer

Instead of comparison methods you may want to just define several types of  Comparator  subclasses inside the Person class   That way you can pass them into standard Collections sorting methods

User · Answer

With Java 8    Comparator comparing  Person p - gt p firstName             thenComparing p- gt p lastName             thenComparingInt p- gt p age     If you have accessor methods   Comparator comparing Person  getFirstName             thenComparing Person  getLastName             thenComparingInt Person  getAge     If a class implements Comparable then such comparator may be used in compareTo method    Override public int compareTo Person o       return Comparator comparing Person  getFirstName                 thenComparing Person  getLastName                 thenComparingInt Person  getAge                 compare this  o

User · Answer

Its easy to do using Google s Guava library   e g  Objects equal name  name2   amp  amp  Objects equal age  age2   amp  amp       More examples    https   stackoverflow com a 5039178 1180621

User · Answer

You can also have a look at Enum that implements Comparator   http   tobega blogspot com 2008 05 beautiful-enums html  e g   Collections sort myChildren  Child Order ByAge descending

User · Answer

You should implement Comparable  lt Person gt   Assuming all fields will not be null  for simplicity sake   that age is an int  and compare ranking is first  last  age  the compareTo method is quite simple   public int compareTo Person other        int i   firstName compareTo other firstName       if  i    0  return i       i   lastName compareTo other lastName       if  i    0  return i       return Integer compare age  other age

User · Answer

Code implementation of the same is here if we have to sort the Person object based on multiple fields   import java util ArrayList  import java util Collections  import java util Comparator   public class Person    private String firstName  private String lastName  private int age   public String getFirstName         return firstName     public void setFirstName String firstName        this firstName   firstName     public String getLastName         return lastName     public void setLastName String lastName        this lastName   lastName     public int getAge         return age     public void setAge int age        this age   age     public Person String firstName  String lastName  int age        this firstName   firstName      this lastName   lastName      this age   age      static class PersonSortingComparator implements Comparator lt Person gt          Override     public int compare Person person1  Person person2                for first name comparison         int firstNameCompare   person1 getFirstName   compareTo person2 getFirstName                 for last name comparison         int lastNameCompare   person1 getLastName   compareTo person2 getLastName                 for last name comparison         int ageCompare   person1 getAge   - person2 getAge                Now comparing         if  firstNameCompare    0                if  lastNameCompare    0                    return ageCompare                            return lastNameCompare                    return firstNameCompare           public static void main String   args        Person person1   new Person  Ajay    Kumar   27       Person person2   new Person  Ajay   Gupta   23       Person person3   new Person  Ajay   Kumar   22         ArrayList lt Person gt  persons   new ArrayList lt  gt         persons add person1       persons add person2       persons add person3         System out println  Before Sorting  n        for  Person person   persons            System out println person firstName         person lastName         person age              Collections sort persons  new PersonSortingComparator          System out println  After Sorting  n        for  Person person   persons            System out println person firstName         person lastName         person age

User · Answer

I think it d be more confusing if your comparison algorithm were  clever   I d go with the numerous comparison methods you suggested   The only exception for me would be equality  For unit testing  it s been useful to me to override the  Equals  in  net  in order to determine if several fields are equal between two objects  and not that the references are equal

User · Answer

If there are multiple ways a user might order person  you could also have multiple Comparators setup as constants somewhere  Most of the sort operations and sorted collections take a comparator as a parameter

User · Answer

Following blog given good chained Comparator example   http   www codejava net java-core collections sorting-a-list-by-multiple-attributes-example  import java util Arrays  import java util Comparator  import java util List          This is a chained comparator that is used to sort a list by multiple    attributes by chaining a sequence of comparators of individual fields    together         public class EmployeeChainedComparator implements Comparator lt Employee gt         private List lt Comparator lt Employee gt  gt  listComparators        SafeVarargs     public EmployeeChainedComparator Comparator lt Employee gt     comparators            this listComparators   Arrays asList comparators               Override     public int compare Employee emp1  Employee emp2            for  Comparator lt Employee gt  comparator   listComparators                int result   comparator compare emp1  emp2               if  result    0                    return result                                  return 0            Calling Comparator   Collections sort listEmployees  new EmployeeChainedComparator                  new EmployeeJobTitleComparator                    new EmployeeAgeComparator                    new EmployeeSalaryComparator

User · Answer

You can implement a Comparator which compares two Person objects  and you can examine as many of the fields as you like  You can put in a variable in your comparator that tells it which field to compare to  although it would probably be simpler to just write multiple comparators

User · Answer

You should implement Comparable  lt Person gt   Assuming all fields will not be null  for simplicity sake   that age is an int  and compare ranking is first  last  age  the compareTo method is quite simple   public int compareTo Person other        int i   firstName compareTo other firstName       if  i    0  return i       i   lastName compareTo other lastName       if  i    0  return i       return Integer compare age  other age

User · Answer

For those able to use the Java 8 streaming API  there is a neater approach that is well documented here  Lambdas and sorting  I was looking for the equivalent of the C  LINQ    ThenBy        I found the mechanism in Java 8 on the Comparator    thenComparing        So here is the snippet that demonstrates the algorithm       Comparator lt Person gt  comparator   Comparator comparing person - gt  person name       comparator   comparator thenComparing Comparator comparing person - gt  person age      Check out the link above for a neater way and an explanation about how Java s type inference makes it a bit more clunky to define compared to LINQ   Here is the full unit test for reference    Test public void testChainedSorting            Create the collection of people      ArrayList lt Person gt  people   new ArrayList lt  gt         people add new Person  Dan   4        people add new Person  Andi   2        people add new Person  Bob   42        people add new Person  Debby   3        people add new Person  Bob   72        people add new Person  Barry   20        people add new Person  Cathy   40        people add new Person  Bob   40        people add new Person  Barry   50            Define chained comparators         Great article explaining this and how to make it even neater         http   blog jooq org 2014 01 31 java-8-friday-goodies-lambdas-and-sorting      Comparator lt Person gt  comparator   Comparator comparing person - gt  person name       comparator   comparator thenComparing Comparator comparing person - gt  person age            Sort the stream      Stream lt Person gt  personStream   people stream   sorted comparator           Make sure that the output is as expected      List lt Person gt  sortedPeople   personStream collect Collectors toList         Assert assertEquals  Andi    sortedPeople get 0  name   Assert assertEquals 2   sortedPeople get 0  age       Assert assertEquals  Barry   sortedPeople get 1  name   Assert assertEquals 20  sortedPeople get 1  age       Assert assertEquals  Barry   sortedPeople get 2  name   Assert assertEquals 50  sortedPeople get 2  age       Assert assertEquals  Bob     sortedPeople get 3  name   Assert assertEquals 40  sortedPeople get 3  age       Assert assertEquals  Bob     sortedPeople get 4  name   Assert assertEquals 42  sortedPeople get 4  age       Assert assertEquals  Bob     sortedPeople get 5  name   Assert assertEquals 72  sortedPeople get 5  age       Assert assertEquals  Cathy   sortedPeople get 6  name   Assert assertEquals 40  sortedPeople get 6  age       Assert assertEquals  Dan     sortedPeople get 7  name   Assert assertEquals 4   sortedPeople get 7  age       Assert assertEquals  Debby   sortedPeople get 8  name   Assert assertEquals 3   sortedPeople get 8  age          Andi       2        Barry      20        Barry      50        Bob        40        Bob        42        Bob        72        Cathy      40        Dan        4        Debby      3           A person in our system      public static class Person                  Creates a new person          param name The name of the person          param age The age of the person              public Person String name  int age                this age   age          this name   name                        The name of the person              public String name                  The age of the person              public int age        Override     public String toString                 if  name    null  return super toString            else return String format   s    d   this name  this age

User · Answer

For those able to use the Java 8 streaming API  there is a neater approach that is well documented here  Lambdas and sorting  I was looking for the equivalent of the C  LINQ    ThenBy        I found the mechanism in Java 8 on the Comparator    thenComparing        So here is the snippet that demonstrates the algorithm       Comparator lt Person gt  comparator   Comparator comparing person - gt  person name       comparator   comparator thenComparing Comparator comparing person - gt  person age      Check out the link above for a neater way and an explanation about how Java s type inference makes it a bit more clunky to define compared to LINQ   Here is the full unit test for reference    Test public void testChainedSorting            Create the collection of people      ArrayList lt Person gt  people   new ArrayList lt  gt         people add new Person  Dan   4        people add new Person  Andi   2        people add new Person  Bob   42        people add new Person  Debby   3        people add new Person  Bob   72        people add new Person  Barry   20        people add new Person  Cathy   40        people add new Person  Bob   40        people add new Person  Barry   50            Define chained comparators         Great article explaining this and how to make it even neater         http   blog jooq org 2014 01 31 java-8-friday-goodies-lambdas-and-sorting      Comparator lt Person gt  comparator   Comparator comparing person - gt  person name       comparator   comparator thenComparing Comparator comparing person - gt  person age            Sort the stream      Stream lt Person gt  personStream   people stream   sorted comparator           Make sure that the output is as expected      List lt Person gt  sortedPeople   personStream collect Collectors toList         Assert assertEquals  Andi    sortedPeople get 0  name   Assert assertEquals 2   sortedPeople get 0  age       Assert assertEquals  Barry   sortedPeople get 1  name   Assert assertEquals 20  sortedPeople get 1  age       Assert assertEquals  Barry   sortedPeople get 2  name   Assert assertEquals 50  sortedPeople get 2  age       Assert assertEquals  Bob     sortedPeople get 3  name   Assert assertEquals 40  sortedPeople get 3  age       Assert assertEquals  Bob     sortedPeople get 4  name   Assert assertEquals 42  sortedPeople get 4  age       Assert assertEquals  Bob     sortedPeople get 5  name   Assert assertEquals 72  sortedPeople get 5  age       Assert assertEquals  Cathy   sortedPeople get 6  name   Assert assertEquals 40  sortedPeople get 6  age       Assert assertEquals  Dan     sortedPeople get 7  name   Assert assertEquals 4   sortedPeople get 7  age       Assert assertEquals  Debby   sortedPeople get 8  name   Assert assertEquals 3   sortedPeople get 8  age          Andi       2        Barry      20        Barry      50        Bob        40        Bob        42        Bob        72        Cathy      40        Dan        4        Debby      3           A person in our system      public static class Person                  Creates a new person          param name The name of the person          param age The age of the person              public Person String name  int age                this age   age          this name   name                        The name of the person              public String name                  The age of the person              public int age        Override     public String toString                 if  name    null  return super toString            else return String format   s    d   this name  this age

User · Answer

Patrick To sort more than one field consecutively try ComparatorChain  A ComparatorChain is a Comparator that wraps one or more Comparators in sequence  The ComparatorChain calls each Comparator in sequence until either 1  any single Comparator returns a non-zero result  and that result is then returned   or 2  the ComparatorChain is exhausted  and zero is returned   This type of sorting is very similar to multi-column sorting in SQL  and this class allows Java classes to emulate that kind of behaviour when sorting a List  To further facilitate SQL-like sorting  the order of any single Comparator in the list can  gt be reversed  Calling a method that adds new Comparators or changes the ascend descend sort after compare Object  Object  has been called will result in an UnsupportedOperationException  However  take care to not alter the underlying List of Comparators or the BitSet that defines the sort order  Instances of ComparatorChain are not synchronized  The class is not thread-safe at construction time  but it is thread-safe to perform multiple comparisons after all the setup operations are complete

User · Answer

Code implementation of the same is here if we have to sort the Person object based on multiple fields   import java util ArrayList  import java util Collections  import java util Comparator   public class Person    private String firstName  private String lastName  private int age   public String getFirstName         return firstName     public void setFirstName String firstName        this firstName   firstName     public String getLastName         return lastName     public void setLastName String lastName        this lastName   lastName     public int getAge         return age     public void setAge int age        this age   age     public Person String firstName  String lastName  int age        this firstName   firstName      this lastName   lastName      this age   age      static class PersonSortingComparator implements Comparator lt Person gt          Override     public int compare Person person1  Person person2                for first name comparison         int firstNameCompare   person1 getFirstName   compareTo person2 getFirstName                 for last name comparison         int lastNameCompare   person1 getLastName   compareTo person2 getLastName                 for last name comparison         int ageCompare   person1 getAge   - person2 getAge                Now comparing         if  firstNameCompare    0                if  lastNameCompare    0                    return ageCompare                            return lastNameCompare                    return firstNameCompare           public static void main String   args        Person person1   new Person  Ajay    Kumar   27       Person person2   new Person  Ajay   Gupta   23       Person person3   new Person  Ajay   Kumar   22         ArrayList lt Person gt  persons   new ArrayList lt  gt         persons add person1       persons add person2       persons add person3         System out println  Before Sorting  n        for  Person person   persons            System out println person firstName         person lastName         person age              Collections sort persons  new PersonSortingComparator          System out println  After Sorting  n        for  Person person   persons            System out println person firstName         person lastName         person age

User · Answer

import com google common collect ComparisonChain           author radler    Class Description         public class Attribute implements Comparable lt Attribute gt         private String type      private String value       public String getType     return type        public void setType String type    this type   type         public String getValue     return value        public void setValue String value    this value   value          Override     public String toString             return  Attribute  type     type      value     value                    Override     public int compareTo Attribute that            return ComparisonChain start                compare this type  that type               compare this value  that value               result

User · Answer

If you implement the Comparable interface  you ll want to choose one simple property to order by  This is known as natural ordering  Think of it as the default  It s always used when no specific comparator is supplied  Usually this is name  but your use case may call for something different  You are free to use any number of other Comparators you can supply to various collections APIs to override the natural ordering   Also note that typically if a compareTo b     0  then a equals b     true  It s ok if not but there are side effects to be aware of  See the excellent javadocs on the Comparable interface and you ll find lots of great information on this

User · Answer

It is easy to compare two objects with hashcode method in java   public class Sample     String a null    String b null     public Sample          a  s         b  a         public Sample String a String b         this a a        this b b        public static void main String args           Sample f new Sample  b   12          Sample s new Sample  b   12            will return true       System out println  s a hashCode   s b hashCode      f a hashCode   f b hashCode               will return false       Sample f new Sample  b   12          Sample s new Sample  b   13          System out println  s a hashCode   s b hashCode      f a hashCode   f b hashCode

User · Answer

Patrick To sort more than one field consecutively try ComparatorChain  A ComparatorChain is a Comparator that wraps one or more Comparators in sequence  The ComparatorChain calls each Comparator in sequence until either 1  any single Comparator returns a non-zero result  and that result is then returned   or 2  the ComparatorChain is exhausted  and zero is returned   This type of sorting is very similar to multi-column sorting in SQL  and this class allows Java classes to emulate that kind of behaviour when sorting a List  To further facilitate SQL-like sorting  the order of any single Comparator in the list can  gt be reversed  Calling a method that adds new Comparators or changes the ascend descend sort after compare Object  Object  has been called will result in an UnsupportedOperationException  However  take care to not alter the underlying List of Comparators or the BitSet that defines the sort order  Instances of ComparatorChain are not synchronized  The class is not thread-safe at construction time  but it is thread-safe to perform multiple comparisons after all the setup operations are complete

User · Answer

I think it d be more confusing if your comparison algorithm were  clever   I d go with the numerous comparison methods you suggested   The only exception for me would be equality  For unit testing  it s been useful to me to override the  Equals  in  net  in order to determine if several fields are equal between two objects  and not that the references are equal

User · Answer

Writing a Comparator manually for such an use case is a terrible solution IMO  Such ad hoc approaches have many drawbacks     No code reuse  Violates DRY  Boilerplate  Increased possibility of errors      So what s the solution   First some theory   Let us denote the proposition  type A supports comparison  by Ord A   From program perspective  you can think of Ord A as an object containing logic for comparing two As  Yes  just like Comparator     Now  if Ord A and Ord B  then their composite  A  B  should also support comparison  i e  Ord  A  B   If Ord A  Ord B  and Ord C  then Ord  A  B  C     We can extend this argument to arbitrary arity  and say   Ord A  Ord B  Ord C       Ord Z   Ord  A  B  C      Z   Let s call this statement 1   The comparison of the composites will work just as you described in your question  the first comparison will be tried first  then the next one  then the next  and so on   That s the first part of our solution  Now the second part   If you know that Ord A  and know how to transform B to A  call that transformation function f   then you can also have Ord B   How  Well  when the two B instances are to be compared   you first transform them to A using f and then apply Ord A   Here  we are mapping the transformation B   A to Ord A   Ord B  This is known as contravariant mapping  or comap for short    Ord A   B   A   comap Ord B  Let s call this statement 2     Now let s apply this to your example    You have a data type named Person that comprises three fields of type String     We know that Ord String  By statement 1  Ord  String  String  String    We can easily write a function from Person to  String  String  String    Just return the three fields    Since we know Ord  String  String  String  and Person    String  String  String   by statement 2  we can use comap to get Ord Person     QED     How do I implement all these concepts   The good news is you don t have to  There already exists a library which implements all the ideas described in this post   If you are curious how these are implemented  you can look under the hood    This is how the code will look with it   Ord lt Person gt  personOrd     p3Ord stringOrd  stringOrd  stringOrd  comap     new F lt Person  P3 lt String  String  String gt  gt           public P3 lt String  String  String gt  f Person x           return p x getFirstName    x getLastname    x getAge                       Explanation    stringOrd is an object of type Ord lt String gt   This corresponds to our original  supports comparison  proposition  p3Ord is a method that takes Ord lt A gt   Ord lt B gt   Ord lt C gt   and returns Ord lt P3 lt A  B  C gt  gt   This corresponds to statement 1   P3 stands for product with three elements  Product is an algebraic term for composites   comap corresponds to well  comap  F lt A  B gt  represents a transformation function A   B  p is a factory method for creating products  The whole expression corresponds to statement 2    Hope that helps

User · Answer

import com google common collect ComparisonChain           author radler    Class Description         public class Attribute implements Comparable lt Attribute gt         private String type      private String value       public String getType     return type        public void setType String type    this type   type         public String getValue     return value        public void setValue String value    this value   value          Override     public String toString             return  Attribute  type     type      value     value                    Override     public int compareTo Attribute that            return ComparisonChain start                compare this type  that type               compare this value  that value               result

User · Answer

If you implement the Comparable interface  you ll want to choose one simple property to order by  This is known as natural ordering  Think of it as the default  It s always used when no specific comparator is supplied  Usually this is name  but your use case may call for something different  You are free to use any number of other Comparators you can supply to various collections APIs to override the natural ordering   Also note that typically if a compareTo b     0  then a equals b     true  It s ok if not but there are side effects to be aware of  See the excellent javadocs on the Comparable interface and you ll find lots of great information on this

User · Answer

You can also have a look at Enum that implements Comparator   http   tobega blogspot com 2008 05 beautiful-enums html  e g   Collections sort myChildren  Child Order ByAge descending

User · Answer

You should implement Comparable  lt Person gt   Assuming all fields will not be null  for simplicity sake   that age is an int  and compare ranking is first  last  age  the compareTo method is quite simple   public int compareTo Person other        int i   firstName compareTo other firstName       if  i    0  return i       i   lastName compareTo other lastName       if  i    0  return i       return Integer compare age  other age

User · Answer

I think it d be more confusing if your comparison algorithm were  clever   I d go with the numerous comparison methods you suggested   The only exception for me would be equality  For unit testing  it s been useful to me to override the  Equals  in  net  in order to determine if several fields are equal between two objects  and not that the references are equal

User · Answer

Its easy to do using Google s Guava library   e g  Objects equal name  name2   amp  amp  Objects equal age  age2   amp  amp       More examples    https   stackoverflow com a 5039178 1180621

User · Answer

Following is the example in jdk 1 8 package com  import java util ArrayList  import java util Comparator  import java util List   class User       private String firstName      private String lastName      private Integer age       public Integer getAge             return age             public User setAge Integer age            this age   age          return this             public String getFirstName             return firstName             public User setFirstName String firstName            this firstName   firstName          return this             public String getLastName             return lastName             public User setLastName String lastName            this lastName   lastName          return this            public class MultiFieldsComparision        public static void main String   args            List lt User gt  users   new ArrayList lt User gt              User u1   new User   setFirstName  Pawan   setLastName  Singh   setAge 38           User u2   new User   setFirstName  Pawan   setLastName  Payal   setAge 37           User u3   new User   setFirstName  Anuj   setLastName  Kumar   setAge 60           User u4   new User   setFirstName  Anuj   setLastName  Kumar   setAge 43           User u5   new User   setFirstName  Pawan   setLastName  Chamoli   setAge 44           User u6   new User   setFirstName  Pawan   setLastName  Singh   setAge 5            users add u1           users add u2           users add u3           users add u4           users add u5           users add u6            System out println         Before Sorting                    users forEach user - gt                System out println user getFirstName             user getLastName             user getAge                          System out println         Aftre Sorting                    users sort                  Comparator comparing User  getFirstName  thenComparing User  getLastName  thenComparing User  getAge             users forEach user - gt                System out println user getFirstName             user getLastName             user getAge

User · Answer

If there are multiple ways a user might order person  you could also have multiple Comparators setup as constants somewhere  Most of the sort operations and sorted collections take a comparator as a parameter

User · Answer

Instead of comparison methods you may want to just define several types of  Comparator  subclasses inside the Person class   That way you can pass them into standard Collections sorting methods

User · Answer

You should implement Comparable  lt Person gt   Assuming all fields will not be null  for simplicity sake   that age is an int  and compare ranking is first  last  age  the compareTo method is quite simple   public int compareTo Person other        int i   firstName compareTo other firstName       if  i    0  return i       i   lastName compareTo other lastName       if  i    0  return i       return Integer compare age  other age

User · Answer

Another option you can always consider is Apache Commons  It provides a lot of options   import org apache commons lang3 builder CompareToBuilder    Ex   public int compare Person a  Person b       return new CompareToBuilder         append a getName    b getName          append a getAddress    b getAddress          toComparison

User · Answer

If there are multiple ways a user might order person  you could also have multiple Comparators setup as constants somewhere  Most of the sort operations and sorted collections take a comparator as a parameter

User · Answer

You can implement a Comparator which compares two Person objects  and you can examine as many of the fields as you like  You can put in a variable in your comparator that tells it which field to compare to  although it would probably be simpler to just write multiple comparators

User · Answer

It is easy to compare two objects with hashcode method in java   public class Sample     String a null    String b null     public Sample          a  s         b  a         public Sample String a String b         this a a        this b b        public static void main String args           Sample f new Sample  b   12          Sample s new Sample  b   12            will return true       System out println  s a hashCode   s b hashCode      f a hashCode   f b hashCode               will return false       Sample f new Sample  b   12          Sample s new Sample  b   13          System out println  s a hashCode   s b hashCode      f a hashCode   f b hashCode

[java] How to compare objects by multiple fields

Examples related to java

Examples related to oop