Comparable vs Comparator

🔍 What Is It?

Comparable<T>:

public interface Comparable<T> {
    int compareTo(T other);
    // Returns: negative if this < other, 0 if equal, positive if this > other
}

• →Implemented by the class itself
• →Defines the "natural ordering"
• →Used by: Collections.sort(), Arrays.sort(), TreeSet, TreeMap
• →Examples: String (alphabetical), Integer (numeric), LocalDate (chronological)

Comparator<T>:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

• →External to the class — can be defined anywhere
• →Defines a specific ordering for a specific purpose
• →Multiple Comparators can exist for the same class
• →Java 8+ has a rich Comparator factory API

Comparator Factory Methods (Java 8+):

• →Comparator.comparing(keyExtractor)
• →Comparator.comparingInt/Long/Double(keyExtractor)
• →comparator.reversed()
• →comparator.thenComparing(keyExtractor)
• →Comparator.naturalOrder() / reverseOrder()
• →Comparator.nullsFirst() / nullsLast()

🎯 Why Do We Need It?

Sorting is fundamental in enterprise applications:

• →Sort orders by date, amount, status
• →Sort users by name, email, registration date
• →Sort products by price, rating, name
• →Sort search results by relevance
• →Display data in user-specified order

Comparable gives a class its default sort order. Comparator gives you flexibility to sort the same data in different ways without modifying the class.

🏗️ What Happens in Real Projects?

Common patterns:

// Sort orders by date (most recent first), then by amount (largest first)
orders.sort(Comparator
    .comparing(Order::getCreatedAt).reversed()
    .thenComparing(Order::getTotalAmount, Comparator.reverseOrder()));

// TreeMap with custom key ordering
TreeMap<String, User> usersByName = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);

// Sort with null safety
employees.sort(Comparator
    .comparing(Employee::getDepartment, Comparator.nullsLast(Comparator.naturalOrder()))
    .thenComparing(Employee::getName));

⚙️ How It Works

compareTo() contract:

• →a.compareTo(b) < 0 means a < b
• →a.compareTo(b) == 0 means a == b (should be consistent with equals())
• →a.compareTo(b) > 0 means a > b
• →Must be antisymmetric: if a < b then b > a
• →Must be transitive: if a < b and b < c then a < c

Consistency with equals:

(a.compareTo(b) == 0) == a.equals(b) should hold (not required but strongly recommended). Violating this causes confusing behavior in sorted collections.

💻 Example

Sorting in Enterprise Code — Implementing Comparable and using the Comparator API for flexible sorting.

// Implementing Comparable for natural ordering
public class Money implements Comparable<Money> {
    private final BigDecimal amount;
    private final String currency;
    
    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    @Override
    public int compareTo(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                "Cannot compare different currencies: " + currency + " vs " + other.currency
            );
        }
        return this.amount.compareTo(other.amount);
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Money other)) return false;
        return this.amount.compareTo(other.amount) == 0  // consistent with compareTo!
            && this.currency.equals(other.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount.stripTrailingZeros(), currency);
    }
}

// Now Money works naturally with sorted collections
TreeSet<Money> prices = new TreeSet<>();
prices.add(new Money(new BigDecimal("29.99"), "USD"));
prices.add(new Money(new BigDecimal("9.99"), "USD"));
prices.add(new Money(new BigDecimal("49.99"), "USD"));
// Automatically sorted: [9.99, 29.99, 49.99]

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits