Comparable接口

1. Comparable接口概述

1.1 基本概念

• 包位置: java.lang.Comparable
• 功能: 定义对象的自然排序规则
• 核心方法: compareTo(T o)
• 用途: 让对象支持排序操作（Arrays.sort、Collections.sort等）

1.2 接口定义

public interface Comparable<T> {
    int compareTo(T o);
}

2. compareTo方法规范

2.1 返回值含义

返回值	含义
负整数	当前对象 < 参数对象
零	当前对象 = 参数对象
正整数	当前对象 > 参数对象

2.2 必须遵守的规则

1. 自反性: x.compareTo(x) == 0
2. 对称性: x.compareTo(y) 与 y.compareTo(x) 符号相反
3. 传递性: 如果 x.compareTo(y) > 0 且 y.compareTo(z) > 0，则 x.compareTo(z) > 0
4. 一致性: 如果 x.compareTo(y) == 0，则 x.compareTo(z) 与 y.compareTo(z) 结果相同

3. 基础使用示例

3.1 基本类型比较

public class BasicComparableExample {
    
    // 包装类已经实现了Comparable
    public static void main(String[] args) {
        Integer a = 10, b = 20;
        String s1 = "apple", s2 = "banana";
        
        System.out.println(a.compareTo(b));  // -1 (10 < 20)
        System.out.println(s1.compareTo(s2)); // -1 ("apple" < "banana")
        
        // 实际应用：排序
        List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
        Collections.sort(numbers);
        System.out.println(numbers); // [1, 2, 5, 8, 9]
    }
}

3.2 自定义类实现Comparable

// 学生类 - 按成绩排序
class Student implements Comparable<Student> {
    private String name;
    private int score;
    
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    @Override
    public int compareTo(Student other) {
        // 按成绩升序排序
        return Integer.compare(this.score, other.score);
    }
    
    // 重写toString和equals方法（推荐）
    @Override
    public String toString() {
        return name + "(" + score + ")";
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return score == student.score && Objects.equals(name, student.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, score);
    }
}

public class StudentExample {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 85),
            new Student("Bob", 92),
            new Student("Charlie", 78)
        );
        
        Collections.sort(students);
        System.out.println("按成绩排序: " + students);
        // 输出: [Charlie(78), Alice(85), Bob(92)]
    }
}

4. 复杂比较逻辑

4.1 多字段比较

class Employee implements Comparable<Employee> {
    private String name;
    private String department;
    private double salary;
    private int yearsOfService;
    
    public Employee(String name, String department, double salary, int years) {
        this.name = name;
        this.department = department;
        this.salary = salary;
        this.yearsOfService = years;
    }
    
    @Override
    public int compareTo(Employee other) {
        // 1. 先按部门排序
        int departmentCompare = this.department.compareTo(other.department);
        if (departmentCompare != 0) {
            return departmentCompare;
        }
        
        // 2. 部门相同，按薪资降序排序
        int salaryCompare = Double.compare(other.salary, this.salary); // 降序
        if (salaryCompare != 0) {
            return salaryCompare;
        }
        
        // 3. 薪资相同，按工龄排序
        return Integer.compare(this.yearsOfService, other.yearsOfService);
    }
    
    @Override
    public String toString() {
        return String.format("%s-%s-%.2f-%d", name, department, salary, yearsOfService);
    }
}

public class MultiFieldComparison {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "IT", 50000, 3),
            new Employee("Bob", "HR", 45000, 2),
            new Employee("Charlie", "IT", 55000, 1),
            new Employee("David", "HR", 45000, 5),
            new Employee("Eve", "IT", 50000, 4)
        );
        
        Collections.sort(employees);
        employees.forEach(System.out::println);
        // 输出顺序:
        // Bob-HR-45000.00-2
        // David-HR-45000.00-5
        // Charlie-IT-55000.00-1
        // Alice-IT-50000.00-3
        // Eve-IT-50000.00-4
    }
}

4.2 使用Comparator.comparing的现代写法

class Product implements Comparable<Product> {
    private String name;
    private String category;
    private double price;
    private int stock;
    
    public Product(String name, String category, double price, int stock) {
        this.name = name;
        this.category = category;
        this.price = price;
        this.stock = stock;
    }
    
    // 使用Java 8的Comparator工具方法
    private static final Comparator<Product> COMPARATOR = 
        Comparator.comparing(Product::getCategory)
                 .thenComparing(Product::getPrice)
                 .thenComparing(Product::getStock, Comparator.reverseOrder());
    
    @Override
    public int compareTo(Product other) {
        return COMPARATOR.compare(this, other);
    }
    
    // Getter方法
    public String getCategory() { return category; }
    public double getPrice() { return price; }
    public int getStock() { return stock; }
    public String getName() { return name; }
    
    @Override
    public String toString() {
        return String.format("%s[%s] $%.2f (%d)", name, category, price, stock);
    }
}

5. 最佳实践和注意事项

5.1 正确的比较实现

class SafeComparableExample {
    
    // ✅ 正确的整数比较 - 避免溢出
    static class SafeIntComparison implements Comparable<SafeIntComparison> {
        private int value;
        
        public SafeIntComparison(int value) { this.value = value; }
        
        @Override
        public int compareTo(SafeIntComparison other) {
            // ✅ 正确：使用Integer.compare
            return Integer.compare(this.value, other.value);
            
            // ❌ 错误：可能溢出
            // return this.value - other.value;
        }
    }
    
    // ✅ 正确处理null
    static class NullSafeComparison implements Comparable<NullSafeComparison> {
        private String text;
        
        public NullSafeComparison(String text) { this.text = text; }
        
        @Override
        public int compareTo(NullSafeComparison other) {
            // 处理null值
            if (this.text == null && other.text == null) return 0;
            if (this.text == null) return -1;
            if (other.text == null) return 1;
            
            return this.text.compareTo(other.text);
        }
    }
    
    // ✅ 保持与equals一致
    static class ConsistentComparison implements Comparable<ConsistentComparison> {
        private final int id;
        private String name;
        
        public ConsistentComparison(int id, String name) {
            this.id = id;
            this.name = name;
        }
        
        @Override
        public int compareTo(ConsistentComparison other) {
            return Integer.compare(this.id, other.id);
        }
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (!(obj instanceof ConsistentComparison)) return false;
            ConsistentComparison other = (ConsistentComparison) obj;
            return this.id == other.id; // 与compareTo保持一致
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
}

5.2 常见陷阱

public class CommonMistakes {
    
    // ❌ 错误示例1：违反对称性
    static class BadComparison1 implements Comparable<BadComparison1> {
        private int value;
        
        @Override
        public int compareTo(BadComparison1 other) {
            // 错误：不满足对称性
            return this.value > other.value ? 1 : -1;
            // 当相等时应该返回0，这里永远返回-1或1
        }
    }
    
    // ❌ 错误示例2：可能抛出异常
    static class BadComparison2 implements Comparable<BadComparison2> {
        private String text;
        
        @Override
        public int compareTo(BadComparison2 other) {
            // 错误：如果text为null会抛出NullPointerException
            return this.text.compareTo(other.text);
        }
    }
    
    // ❌ 错误示例3：与equals不一致
    static class BadComparison3 implements Comparable<BadComparison3> {
        private int id;
        private String name;
        
        @Override
        public int compareTo(BadComparison3 other) {
            return this.name.compareTo(other.name);
        }
        
        @Override
        public boolean equals(Object obj) {
            // 错误：compareTo按name比较，equals按id比较
            if (!(obj instanceof BadComparison3)) return false;
            return this.id == ((BadComparison3) obj).id;
        }
    }
}

6. 实际应用场景

6.1 在集合中的使用

public class CollectionApplications {
    
    public static void main(String[] args) {
        // 1. TreeSet/TreeMap自动排序
        Set<String> sortedSet = new TreeSet<>();
        sortedSet.add("orange");
        sortedSet.add("apple");
        sortedSet.add("banana");
        System.out.println("TreeSet: " + sortedSet); // [apple, banana, orange]
        
        // 2. 优先队列
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.offer(5);
        pq.offer(1);
        pq.offer(3);
        System.out.print("PriorityQueue: ");
        while (!pq.isEmpty()) {
            System.out.print(pq.poll() + " "); // 1 3 5
        }
        System.out.println();
        
        // 3. 二分查找
        List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 9);
        int index = Collections.binarySearch(numbers, 5);
        System.out.println("二分查找结果: " + index); // 2
        
        // 4. 最大值/最小值
        List<Student> students = Arrays.asList(
            new Student("A", 80), new Student("B", 95), new Student("C", 70)
        );
        Student topStudent = Collections.max(students);
        Student bottomStudent = Collections.min(students);
        System.out.println("最高分: " + topStudent);
        System.out.println("最低分: " + bottomStudent);
    }
}

6.2 复杂业务场景

// 电商商品排序
class ECommerceProduct implements Comparable<ECommerceProduct> {
    private String name;
    private double price;
    private double rating;
    private int sales;
    private Date createTime;
    
    // 多种排序策略
    public enum SortBy {
        PRICE_ASC, PRICE_DESC, RATING, SALES, NEWEST
    }
    
    private SortBy currentSort = SortBy.PRICE_ASC;
    
    public void setSortBy(SortBy sortBy) {
        this.currentSort = sortBy;
    }
    
    @Override
    public int compareTo(ECommerceProduct other) {
        switch (currentSort) {
            case PRICE_ASC:
                return Double.compare(this.price, other.price);
            case PRICE_DESC:
                return Double.compare(other.price, this.price);
            case RATING:
                return Double.compare(other.rating, this.rating); // 评分高的在前
            case SALES:
                return Integer.compare(other.sales, this.sales); // 销量高的在前
            case NEWEST:
                return other.createTime.compareTo(this.createTime); // 新的在前
            default:
                return Double.compare(this.price, other.price);
        }
    }
}

7. 与Comparator的区别

特性	Comparable	Comparator
包位置	java.lang	java.util
方法	compareTo(T o)	compare(T o1, T o2)
排序类型	自然排序	定制排序
实现位置	在要排序的类中实现	单独的类或匿名类
使用场景	单一的、默认的排序规则	多种排序规则

// Comparator使用示例
public class ComparatorVsComparable {
    
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 85),
            new Student("Bob", 92),
            new Student("Charlie", 78)
        );
        
        // 使用Comparable（自然排序）
        Collections.sort(students);
        System.out.println("自然排序: " + students);
        
        // 使用Comparator（定制排序）
        Collections.sort(students, (s1, s2) -> s1.getName().compareTo(s2.getName()));
        System.out.println("按姓名排序: " + students);
        
        // 或者使用方法引用
        Collections.sort(students, Comparator.comparing(Student::getName));
    }
}

总结要点

1. 实现原则: 遵守compareTo方法的数学规范
2. 一致性: 尽量保持compareTo与equals方法一致
3. 安全性: 处理可能的null值和边界情况
4. 性能: 对于复杂比较，考虑性能影响
5. 可读性: 多字段比较时保持代码清晰
6. 灵活性: 需要多种排序方式时考虑使用Comparator

Comparable接口是Java集合框架的基石之一，正确实现它对于使用排序相关的集合类至关重要。