Java TreeSet Drops Objects — compareTo Equality Trap

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) {\n            this.name = name;\n            this.price = price;\n            this.category = category;\n        }

        // 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.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// Java 17 record implementing Comparable.
// Records are immutable by design, making them safe for sorted collections.
public record TransactionRecord(long id, double amount, LocalDateTime timestamp)
        implements Comparable<TransactionRecord> {

    // Compact constructor validates non-null timestamp (avoid NPE in compareTo)
    public TransactionRecord {
        if (timestamp == null) {
            throw new IllegalArgumentException("timestamp must not be null");
        }
    }

    // Natural ordering: by timestamp ascending
    @Override
    public int compareTo(TransactionRecord other) {
        return this.timestamp.compareTo(other.timestamp);
    }

    public static void main(String[] args) {
        List<TransactionRecord> transactions = new ArrayList<>();
        transactions.add(new TransactionRecord(1001, 250.00, LocalDateTime.of(2026, 5, 8, 10, 30)));
        transactions.add(new TransactionRecord(1002, 99.99, LocalDateTime.of(2026, 5, 7, 9, 15)));
        transactions.add(new TransactionRecord(1003, 1500.00, LocalDateTime.of(2026, 5, 7, 16, 45)));
        transactions.add(new TransactionRecord(1004, 42.50, LocalDateTime.of(2026, 5, 9, 8, 0)));

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

        Collections.sort(transactions);

        System.out.println("\n=== Sorted by Timestamp (Natural Order) ===");
        transactions.forEach(System.out::println);

        // If you need a different ordering, supply a Comparator:
        // transactions.sort(Comparator.comparingDouble(TransactionRecord::amount).reversed());
    }
}

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) {\n            this.firstName = firstName;\n            this.lastName = lastName;\n            this.department = department;\n            this.annualSalary = annualSalary;\n            this.yearsOfService = yearsOfService;\n        }

        // 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.util.*;

public class ComplexChainingExample {

    static class Employee {
        private final String name;
        private final String department;
        private final double salary;
        private final int years;

        public Employee(String name, String department, double salary, int years) {\n            this.name = name;\n            this.department = department;\n            this.salary = salary;\n            this.years = years;\n        }

        public String getName() { return name; }
        public String getDepartment() { return department; }
        public double getSalary() { return salary; }
        public int getYears() { return years; }

        @Override
        public String toString() {
            return String.format("%-12s %-15s $%8.0f %dyrs", name, department, salary, years);
        }
    }

    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice",   "Engineering", 120000, 5),
            new Employee("Bob",     "Engineering", 95000,  8),
            new Employee("Charlie", "Marketing",   110000, 3),
            new Employee("Diana",   "Marketing",   110000, 6),
            new Employee("Eve",     "Engineering", 120000, 3)
        );

        // Pattern 1: Department ASC, then Salary DESC, then Years ASC
        // reversed() is applied only to the salary comparator before chaining
        Comparator<Employee> byDeptThenSalaryDescThenYears =
            Comparator.comparing(Employee::getDepartment)
                      .thenComparing(Comparator.comparingDouble(Employee::getSalary).reversed())
                      .thenComparingInt(Employee::getYears);

        System.out.println("=== Department ASC, Salary DESC, Years ASC ===");
        employees.stream().sorted(byDeptThenSalaryDescThenYears).forEach(System.out::println);

        // Pattern 2: Entire chain reversed — now Department DESC, Salary ASC, Years DESC
        Comparator<Employee> reversedWhole = byDeptThenSalaryDescThenYears.reversed();
        System.out.println("\n=== Reversed Whole: Department DESC, Salary ASC, Years DESC ===");
        employees.stream().sorted(reversedWhole).forEach(System.out::println);

        // Pattern 3: With null handling — if department could be null, use nullsFirst
        Comparator<Employee> withNulls =
            Comparator.comparing(Employee::getDepartment,
                                 Comparator.nullsFirst(String::compareTo))
                      .thenComparing(Employee::getSalary);
        // (Assuming list has null departments, but not shown for brevity)
    }
}

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> {\n        private final int    orderId;\n        private final String customerName;\n        private final double totalAmount;\n        private final LocalDate dueDate;\n        private final String status;\n\n        public Order(int orderId, String customerName,\n                     double totalAmount, LocalDate dueDate, String status) {\n            this.orderId      = orderId;\n            this.customerName = customerName;\n            this.totalAmount  = totalAmount;\n            this.dueDate      = dueDate;\n            this.status       = status;\n        }

        // 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);
    }
}

import java.util.*;

public class NullSafeSorting {

    static class Employee {
        private final String name;
        private final Double salary;  // nullable

        public Employee(String name, Double salary) {\n            this.name = name;\n            this.salary = salary;\n        }

        public Double getSalary() { return salary; }

        @Override
        public String toString() {
            return name + " - $" + (salary == null ? "null" : String.format("%.0f", salary));
        }
    }

    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("Alice", 75000.0));
        employees.add(new Employee("Bob", null));
        employees.add(new Employee("Charlie", 82000.0));
        employees.add(new Employee("Diana", null));
        employees.add(new Employee("Eve", 68000.0));

        // Without null handling, this line would throw NPE:
        // employees.sort(Comparator.comparing(Employee::getSalary));

        // Safe: nullsLast — null salaries go to the end
        Comparator<Employee> bySalaryNullsLast =
            Comparator.nullsLast(Comparator.comparing(Employee::getSalary));

        System.out.println("=== Sorted by Salary, nulls last ===");
        employees.sort(bySalaryNullsLast);
        employees.forEach(System.out::println);

        // Alternative: nullsFirst — nulls at the beginning
        List<Employee> copy = new ArrayList<>(employees);  // unsort to show effect
        Collections.shuffle(copy);
        Comparator<Employee> bySalaryNullsFirst =
            Comparator.nullsFirst(Comparator.comparing(Employee::getSalary));
        copy.sort(bySalaryNullsFirst);
        System.out.println("\n=== Sorted by Salary, nulls first ===");
        copy.forEach(System.out::println);
    }
}

import java.util.*;
import java.util.function.ToIntFunction;

public class SortPerformanceDemo {

    static class Employee {
        private final String name;
        private final int age;
        private final double salary;
        // imagine a costly field
        private final int yearsOfService;

        public Employee(String name, int age, double salary, int years) {\n            this.name = name;\n            this.age = age;\n            this.salary = salary;\n            this.yearsOfService = years;\n        }

        public int getAge() { return age; }
        public double getSalary() { return salary; }
        public int getYearsOfService() { return yearsOfService; }

        // Expensive calculation — in reality could be a database call
        private int expensiveComputation() {
            // Simulate some complex logic
            return (int)(salary / yearsOfService * 100);
        }
    }

    // Static final comparator — reused across calls
    private static final Comparator<Employee> BY_AGE_FAST =
        (a, b) -> Integer.compare(a.getAge(), b.getAge());

    // Alternative using comparingInt — faster than comparing() for primitives
    private static final Comparator<Employee> BY_AGE_USING_INT =
        Comparator.comparingInt(Employee::getAge);

    // A comparator that calls an expensive method every time — BAD!
    private static final Comparator<Employee> BY_EXPENSIVE_WRONG =
        (a, b) -> Integer.compare(a.expensiveComputation(), b.expensiveComputation());

    // Better: precompute keys using one pass then sort indices
    public static void main(String[] args) {
        List<Employee> employees = generate(10000);

        long start = System.nanoTime();
        employees.sort(BY_AGE_FAST);
        long end = System.nanoTime();
        System.out.println("Static final comparator: " + (end - start) / 1_000_000 + " ms");

        // Compare with inline lambda — slight overhead from method reference
        start = System.nanoTime();
        employees.sort(Comparator.comparingInt(Employee::getAge));
        end = System.nanoTime();
        System.out.println("Inline comparingInt: " + (end - start) / 1_000_000 + " ms");
    }

    private static List<Employee> generate(int n) {
        List<Employee> list = new ArrayList<>();
        Random rnd = new Random();
        for (int i = 0; i < n; i++) {
            list.add(new Employee("E" + i, rnd.nextInt(50) + 20,
                                  rnd.nextDouble() * 100000, rnd.nextInt(30) + 1));
        }
        return list;
    }
}