What is the difference between Comparable and Comparator?

package com.bank.model;

import java.math.BigDecimal;
import java.time.LocalDate;

// Comparable: natural ordering by account ID
public class Account implements Comparable<Account> {
    private final String accountId;
    private final String holder;
    private final BigDecimal balance;
    private final LocalDate openDate;

    public Account(String accountId, String holder, BigDecimal balance, LocalDate openDate) {
        this.accountId = accountId;
        this.holder = holder;
        this.balance = balance;
        this.openDate = openDate;
    }

    @Override
    public int compareTo(Account other) {
        return this.accountId.compareTo(other.accountId); // natural order: by ID
    }

    // getters
    public String getAccountId() { return accountId; }
    public String getHolder() { return holder; }
    public BigDecimal getBalance() { return balance; }
    public LocalDate getOpenDate() { return openDate; }

    @Override
    public String toString() {
        return accountId + " (" + holder + ": " + balance + ")";
    }
}

package com.bank.demo;

import com.bank.model.Account;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.*;

public class ComparableVsComparatorDemo {
    public static void main(String[] args) {
        List<Account> accounts = new ArrayList<>(List.of(
            new Account("SAV2001", "Rajesh", new BigDecimal("150000"), LocalDate.of(2020, 1, 15)),
            new Account("CUR3001", "Priya", new BigDecimal("75000"), LocalDate.of(2021, 6, 1)),
            new Account("FD4001", "Amit", new BigDecimal("500000"), LocalDate.of(2019, 3, 20))
        ));

        // Comparable: natural order (by account ID)
        Collections.sort(accounts);
        System.out.println("Natural order (Comparable):");
        accounts.forEach(a -> System.out.println("  " + a));

        // Comparator: sort by balance ascending
        accounts.sort(Comparator.comparing(Account::getBalance));
        System.out.println("\nBy balance (Comparator):");
        accounts.forEach(a -> System.out.println("  " + a));

        // Comparator: sort by balance descending, then by name
        accounts.sort(
            Comparator.comparing(Account::getBalance).reversed()
                      .thenComparing(Account::getHolder)
        );
        System.out.println("\nBy balance desc, then name:");
        accounts.forEach(a -> System.out.println("  " + a));
    }
}

Natural order (Comparable):
  CUR3001 (Priya: 75000)
  FD4001 (Amit: 500000)
  SAV2001 (Rajesh: 150000)

By balance (Comparator):
  CUR3001 (Priya: 75000)
  SAV2001 (Rajesh: 150000)
  FD4001 (Amit: 500000)

By balance desc, then name:
  FD4001 (Amit: 500000)
  SAV2001 (Rajesh: 150000)
  CUR3001 (Priya: 75000)

// Basic comparing
Comparator.comparing(Account::getBalance)                    // by balance
Comparator.comparing(Account::getHolder)                     // by holder name
Comparator.comparing(Account::getOpenDate)                   // by open date

// Primitive-specific (avoid autoboxing)
Comparator.comparingInt(Employee::getAge)                    // int field
Comparator.comparingLong(Trade::getTimestamp)                // long field
Comparator.comparingDouble(Product::getPrice)                // double field

// Reverse
Comparator.comparing(Account::getBalance).reversed()         // descending

// Chaining (multi-level sort)
Comparator.comparing(Account::getHolder)
          .thenComparing(Account::getBalance)                // tie-breaker
          .thenComparing(Account::getOpenDate)               // second tie-breaker

// Null handling
Comparator.nullsFirst(Comparator.comparing(Account::getHolder))  // nulls first
Comparator.nullsLast(Comparator.naturalOrder())              // nulls last

// Case-insensitive
Comparator.comparing(Account::getHolder, String.CASE_INSENSITIVE_ORDER)

package com.bank.demo;

import java.util.*;

public class CompareToEqualityGotcha {
    public static void main(String[] args) {
        // Case-insensitive comparator: "abc".compareTo("ABC") == 0
        TreeSet<String> set = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
        set.add("abc");
        set.add("ABC"); // compareTo == 0 → treated as duplicate!
        System.out.println("TreeSet size: " + set.size()); // 1, not 2!
        System.out.println("TreeSet: " + set); // [abc]

        // HashSet uses equals: "abc".equals("ABC") == false
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("abc");
        hashSet.add("ABC");
        System.out.println("HashSet size: " + hashSet.size()); // 2
    }
}

TreeSet size: 1
TreeSet: [abc]
HashSet size: 2

// WRONG: compareTo returns 0 for accounts with same balance
// but equals checks account ID
@Override public int compareTo(Account other) {
    return this.balance.compareTo(other.balance);
}
@Override public boolean equals(Object o) {
    return o instanceof Account a && a.accountId.equals(this.accountId);
}
// TreeSet with this: two accounts with same balance → one is dropped!
// Fix: add a tiebreaker to compareTo
@Override public int compareTo(Account other) {
    int cmp = this.balance.compareTo(other.balance);
    return cmp != 0 ? cmp : this.accountId.compareTo(other.accountId);
}

// WRONG: can overflow for large values
@Override public int compareTo(Account other) {
    return this.priority - other.priority; // overflow if values are far apart!
}

// CORRECT: use Integer.compare
@Override public int compareTo(Account other) {
    return Integer.compare(this.priority, other.priority);
}