Comparable vs Comparator in Java — Sorting Objects the Right Way

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// Product implements Comparable so it knows its own natural ordering: price ascending.
public class ProductSortByPrice {

    // Inner class representing a store product.
    // Implementing Comparable<Product> means THIS class defines the default sort order.
    static class Product implements Comparable<Product> {
        private final String name;
        private final double price;
        private final String category;

        public Product(String name, double price, String category) {
            this.name = name;
            this.price = price;
            this.category = category;
        }

        // compareTo is the heart of Comparable.
        // Return negative  -> this product comes BEFORE other (lower price = earlier in list)
        // Return zero      -> same price, treated as equal for ordering purposes
        // Return positive  -> this product comes AFTER other
        @Override
        public int compareTo(Product other) {
            // Double.compare handles NaN edge cases safely — never subtract doubles directly!
            return Double.compare(this.price, other.price);
        }

        @Override
        public String toString() {
            return String.format("%-20s $%.2f  [%s]", name, price, category);
        }
    }

    public static void main(String[] args) {
        List<Product> inventory = new ArrayList<>();
        inventory.add(new Product("Wireless Mouse",    29.99, "Electronics"));
        inventory.add(new Product("Desk Lamp",         14.49, "Office"));
        inventory.add(new Product("Mechanical Keyboard",89.00, "Electronics"));
        inventory.add(new Product("Notebook Pack",      6.99, "Stationery"));
        inventory.add(new Product("USB Hub",            22.50, "Electronics"));

        System.out.println("=== Unsorted Inventory ===");
        inventory.forEach(System.out::println);

        // Collections.sort calls compareTo on each Product internally.
        // No extra instructions needed — the Product knows how to sort itself.
        Collections.sort(inventory);

        System.out.println("\n=== Sorted by Price (Natural Order via Comparable) ===");
        inventory.forEach(System.out::println);
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class EmployeeMultiSort {

    // Employee does NOT implement Comparable — we deliberately leave the class
    // flexible and handle all sorting externally with Comparator.
    static class Employee {
        private final String firstName;
        private final String lastName;
        private final String department;
        private final double annualSalary;
        private final int yearsOfService;

        public Employee(String firstName, String lastName,
                        String department, double annualSalary, int yearsOfService) {
            this.firstName = firstName;
            this.lastName = lastName;
            this.department = department;
            this.annualSalary = annualSalary;
            this.yearsOfService = yearsOfService;
        }

        // Getters — Comparator.comparing() needs method references to these.
        public String getFirstName()    { return firstName; }
        public String getLastName()     { return lastName; }
        public String getDepartment()   { return department; }
        public double getAnnualSalary() { return annualSalary; }
        public int getYearsOfService()  { return yearsOfService; }

        @Override
        public String toString() {
            return String.format("%-12s %-12s | %-12s | $%,8.0f | %d yrs",
                    firstName, lastName, department, annualSalary, yearsOfService);
        }
    }

    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("Sarah",   "Chen",    "Engineering", 112000, 5));
        employees.add(new Employee("Marcus",  "Rivera",  "Marketing",    78000, 3));
        employees.add(new Employee("Priya",   "Sharma",  "Engineering",  98000, 7));
        employees.add(new Employee("James",   "Okafor",  "Marketing",    82000, 3));
        employees.add(new Employee("Lena",    "Novak",   "Engineering", 112000, 2));
        employees.add(new Employee("David",   "Kim",     "HR",           67000, 8));

        // --- Strategy 1: Sort by last name only (simplest Comparator) ---
        Comparator<Employee> byLastName = Comparator.comparing(Employee::getLastName);

        System.out.println("=== Sorted by Last Name ===");
        employees.stream()
                 .sorted(byLastName)
                 .forEach(System.out::println);

        // --- Strategy 2: Multi-field sort — department ASC, salary DESC, last name ASC ---
        // thenComparing chains are evaluated left-to-right, just like ORDER BY in SQL.
        Comparator<Employee> byDeptThenSalaryDescThenName =
            Comparator.comparing(Employee::getDepartment)           // primary: dept A-Z
                      .thenComparing(
                          Comparator.comparingDouble(Employee::getAnnualSalary).reversed() // salary high-to-low
                      )
                      .thenComparing(Employee::getLastName);        // tie-break: last name A-Z

        System.out.println("\n=== Sorted by Department > Salary (desc) > Last Name ===");
        employees.stream()
                 .sorted(byDeptThenSalaryDescThenName)
                 .forEach(System.out::println);

        // --- Strategy 3: Inline anonymous lambda — useful for one-off sorts ---
        System.out.println("\n=== Sorted by Years of Service (most senior first) ===");
        employees.stream()
                 .sorted((emp1, emp2) -> Integer.compare(emp2.getYearsOfService(),
                                                         emp1.getYearsOfService()))
                 .forEach(System.out::println);
    }
}

import java.time.LocalDate;
import java.util.*;

public class OrderSortingDashboard {

    // Order has a natural ordering by orderId (Comparable),
    // but we expose named Comparators for other departments.
    static class Order implements Comparable<Order> {
        private final int    orderId;
        private final String customerName;
        private final double totalAmount;
        private final LocalDate dueDate;
        private final String status;

        public Order(int orderId, String customerName,
                     double totalAmount, LocalDate dueDate, String status) {
            this.orderId      = orderId;
            this.customerName = customerName;
            this.totalAmount  = totalAmount;
            this.dueDate      = dueDate;
            this.status       = status;
        }

        // Natural ordering: by orderId ascending — logical default for any order system.
        @Override
        public int compareTo(Order other) {
            return Integer.compare(this.orderId, other.orderId);
        }

        // Named Comparators as static constants — keeps sort logic next to the class
        // but doesn't lock the class into a single ordering.
        public static final Comparator<Order> BY_DUE_DATE =
            Comparator.comparing(o -> o.dueDate);  // Fulfilment team view

        public static final Comparator<Order> BY_AMOUNT_DESCENDING =
            Comparator.comparingDouble((Order o) -> o.totalAmount).reversed(); // Finance view

        public static final Comparator<Order> BY_CUSTOMER_THEN_AMOUNT =
            Comparator.comparing((Order o) -> o.customerName)
                      .thenComparingDouble(o -> o.totalAmount); // Admin view

        @Override
        public String toString() {
            return String.format("#%04d | %-18s | $%8.2f | Due: %s | %s",
                    orderId, customerName, totalAmount, dueDate, status);
        }
    }

    public static void main(String[] args) {
        List<Order> orders = Arrays.asList(
            new Order(1042, "Acme Corp",       4250.00, LocalDate.of(2025, 8, 15), "Processing"),
            new Order(1038, "Bright Ideas Ltd",  980.50, LocalDate.of(2025, 7, 30), "Shipped"),
            new Order(1055, "Acme Corp",         310.00, LocalDate.of(2025, 8, 2),  "Pending"),
            new Order(1029, "Nova Systems",     7800.00, LocalDate.of(2025, 7, 25), "Processing"),
            new Order(1061, "Delta Supplies",   1540.75, LocalDate.of(2025, 8, 10), "Pending")
        );

        // Default: TreeSet uses Comparable (orderId) — no Comparator needed.
        TreeSet<Order> orderedById = new TreeSet<>(orders);
        System.out.println("=== Default View: Sorted by Order ID (Comparable) ===");
        orderedById.forEach(System.out::println);

        // Fulfilment team: most urgent first.
        List<Order> fulfilmentView = new ArrayList<>(orders);
        fulfilmentView.sort(Order.BY_DUE_DATE);
        System.out.println("\n=== Fulfilment View: Sorted by Due Date ===");
        fulfilmentView.forEach(System.out::println);

        // Finance team: highest value orders first.
        List<Order> financeView = new ArrayList<>(orders);
        financeView.sort(Order.BY_AMOUNT_DESCENDING);
        System.out.println("\n=== Finance View: Sorted by Amount (Descending) ===");
        financeView.forEach(System.out::println);

        // Admin: alphabetical by customer, then by amount within same customer.
        List<Order> adminView = new ArrayList<>(orders);
        adminView.sort(Order.BY_CUSTOMER_THEN_AMOUNT);
        System.out.println("\n=== Admin View: Sorted by Customer > Amount ===");
        adminView.forEach(System.out::println);
    }
}