Analysis and Optimization of Multi-Field Object Collection Sorting in Java

Problem Background and Common Mistakes

In Java development, sorting object collections based on multiple fields is a frequent requirement. A common mistake is to directly concatenate multiple string fields for sorting, as shown in the original code:

Collections.sort(reportList, new Comparator<Report>() {
    @Override
    public int compare(final Report record1, final Report record2) {
        return (record1.getReportKey() + record1.getStudentNumber() + record1.getSchool())
            .compareTo(record2.getReportKey() + record2.getStudentNumber() + record2.getSchool());
    }
});

This approach has serious flaws. When field values have different lengths, comparing concatenated strings produces incorrect results. For example, records with ReportKey as "A1", StudentNumber as "2", School as "X" and ReportKey as "A", StudentNumber as "12", School as "X" concatenate to "A12X" and "A12X" respectively, leading to erroneous comparison results.

Correct Multi-Field Sorting Implementation

Traditional Manual Comparison Method

The most fundamental and reliable approach is to compare fields one by one:

@Override
public int compare(final Report record1, final Report record2) {
    int c;
    c = record1.getReportKey().compareTo(record2.getReportKey());
    if (c == 0)
        c = record1.getStudentNumber().compareTo(record2.getStudentNumber());
    if (c == 0)
        c = record1.getSchool().compareTo(record2.getSchool());
    return c;
}

This method offers clear logic and excellent performance but results in verbose code that is difficult to maintain, especially as the number of fields increases.

Google Guava ComparisonChain

Using the Guava library significantly simplifies the code:

public class ReportComparator implements Comparator<Report> {
    public int compare(Report r1, Report r2) {
        return ComparisonChain.start()
            .compare(r1.getReportKey(), r2.getReportKey())
            .compare(r1.getStudentNumber(), r2.getStudentNumber())
            .compare(r1.getSchool(), r2.getSchool())
            .result();
    }
}

ComparisonChain provides a fluent API, making the code concise and readable, while built-in null value handling is included.

Apache Commons CompareToBuilder

Apache Commons offers a similar solution:

Collections.sort(reportList, new Comparator<Report>() {
    @Override
    public int compare(Report r1, Report r2) {
        return new CompareToBuilder()
            .append(r1.getReportKey(), r2.getReportKey())
            .append(r1.getStudentNumber(), r2.getStudentNumber())
            .append(r1.getSchool(), r2.getSchool())
            .toComparison();
    }
});

This approach is equally concise and automatically handles null values, though it offers less flexibility.

Java 8 Lambda Expressions

Java 8 introduced functional programming support, providing the most elegant solution:

Collections.sort(reportList, Comparator.comparing(Report::getReportKey)
    .thenComparing(Report::getStudentNumber)
    .thenComparing(Report::getSchool));

This method offers multiple advantages: concise code, type safety, support for automatic refactoring, and lazy evaluation of getter methods for better performance. It is currently the most recommended implementation.

Performance Analysis and Best Practices

Different methods vary in performance. The traditional manual comparison method performs best but has low development efficiency. Third-party library methods excel in readability and maintainability but introduce external dependencies. Java 8 Lambda methods achieve the best balance between development efficiency and runtime performance.

In practical applications, it is recommended to: use Java 8 Lambda for simple scenarios; consider Guava ComparisonChain for complex sorting logic; and use traditional manual comparison for performance-sensitive situations.

Extended Application Scenarios

Multi-field sorting is not limited to string types but applies to various data types such as numbers and dates. By combining different Comparators, complex sorting logic can be implemented, including descending order and custom sorting rules.

Additionally, in multi-threaded environments, it is essential to ensure that Comparator implementations are thread-safe to avoid modifying object states during comparison.