Why is Java 8\'s Lambda Approach the Best Way to Sort Objects with Multiple Fields?

Using Java 8 lambda's (added April 10, 2019)

This version of the code takes advantage of Java 8 lambda's to achieve the desired sorting result:

<code class="java">Collections.sort(reportList, Comparator.comparing(Report::getReportKey)
            .thenComparing(Report::getStudentNumber)
            .thenComparing(Report::getSchool));</code>

The key here is to use the thenComparing method to create a chain of comparators. Each comparator in the chain compares one of the fields in the Report object. The resulting comparator is then used to sort the list.

This approach is concise, easy to read, and type-safe. It also has the advantage of lazily evaluating the getters, meaning that the getters are only called when they are needed for the comparison.

Messy and convoluted: Sorting by hand

The original code, which sorts by hand, is verbose and error-prone. It requires a lot of typing and maintenance, and it is easy to make mistakes when writing the comparison logic. Here's what it looked like:

<code class="java">Collections.sort(reportList, new Comparator<report>() {

  @Override
  public int compare(Report record1, Report record2) {
    return (record1.getReportKey() + record1.getStudentNumber() + record1.getSchool())                      
        .compareTo(record2.getReportKey() + record2.getStudentNumber() + record2.getSchool());
  }

});</report></code>

This approach is not recommended for sorting objects with multiple fields.

The reflective way: Sorting with BeanComparator

The BeanComparator approach uses reflection to compare the fields of the Report objects. This approach is more concise than sorting by hand, but it is also more error-prone and slower. Here's what it looked like:

<code class="java">ComparatorChain chain = new ComparatorChain(Arrays.asList(
   new BeanComparator("reportKey"),
   new BeanComparator("studentNumber"),
   new BeanComparator("school")));

Collections.sort(reportList, chain);  </code>

This approach is not recommended for sorting objects with multiple fields.

Getting there: Sorting with Google Guava’s ComparisonChain

The Google Guava ComparisonChain approach is similar to the BeanComparator approach, but it is more flexible and faster. Here's what it looked like:

<code class="java">Collections.sort(reportList, new Comparator<report>() {  

  @Override  
  public int compare(Report p1, Report p2) {  
    return ComparisonChain.start().compare(p1.getReportKey(), p2.getReportKey()).compare(p1.getStudentNumber(), p2.getStudentNumber()).compare(p1.getSchool(), p2.getSchool()).result();  
  }  
});  </report></code>

This approach is a good choice for sorting objects with multiple fields, but it is not as concise as the Java 8 lambda approach.

Sorting with Apache Commons CompareToBuilder

The Apache Commons CompareToBuilder approach is similar to the Google Guava ComparisonChain approach, but it is less flexible. Here's what it looked like:

<code class="java">Collections.sort(reportList, new Comparator<report>() {  

  @Override  
  public int compare(Report p1, Report p2) {  
    return new CompareToBuilder().append(p1.getReportKey(), p2.getReportKey()).append(p1.getStudentNumber(), p2.getStudentNumber()).append(p1.getSchool(), p2.getSchool()).toComparison();  
  }  
});  </report></code>

This approach is a good choice for sorting objects with multiple fields, but it is not as concise as the Java 8 lambda approach.

Thus

Ultimately, the best approach for sorting objects with multiple fields depends on the specific requirements of the application. The Java 8 lambda approach is the most concise and type-safe, but it requires Java 8 or later. The Google Guava ComparisonChain approach is a good choice for applications that need more flexibility than the Java 8 lambda approach, but it is not as concise. The Apache Commons CompareToBuilder approach is a good choice for applications that need less flexibility than the Google Guava ComparisonChain approach, but it is not as concise.

The above is the detailed content of Why is Java 8\'s Lambda Approach the Best Way to Sort Objects with Multiple Fields?. For more information, please follow other related articles on the PHP Chinese website!