（自定义排序）Arrays.sort(T[],Comparator)详解（保姆级别的教学）

一、基础概念

Arrays.sort(T[], Comparator) 是Java中用于自定义排序规则的核心方法，允许你灵活控制元素的排列顺序。 核心作用：

• 对数组按任意规则排序（如数位和、字符串长度等）
• 支持多条件排序（先比A再比B）

二、基础语法模板

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        // 定义数组（必须用对象类型，如Integer、String）
        Integer[] numbers = {5, 12, 3, 20, 11};

        // 使用自定义比较器排序
        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                // 在这里写你的排序规则
                return a - b; // 基础升序示例
            }
        });
    }
}

三、比较器规则详解

1. compare(a, b) 返回值逻辑

返回值	排序行为	对应场景
负数	a 排在 b 前面	当 a 应该比 b 小（升序）
正数	a 排在 b 后面	当 a 应该比 b 大（降序）
0	顺序不变（视为相等）	通常无需处理，稳定排序保留原顺序

2. 经典案例：按数位和排序（贴合你的图像规则）

Arrays.sort(numbers, new Comparator<Integer>() {
    @Override
    public int compare(Integer a, Integer b) {
        // 规则1：优先按数位和升序
        int sumA = digitSum(a);
        int sumB = digitSum(b);
        if (sumA != sumB) {
            return sumA - sumB; // 数位和小者排前
        }
        
        // 规则2：数位和相同则按数值升序
        return a - b;
    }
    
    // 计算数位和的辅助方法
    private int digitSum(int num) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }
});

四、常见场景实战

场景1：简单升序/降序

// 升序（默认）
Arrays.sort(array, (a, b) -> a - b);

// 降序（反转差值）
Arrays.sort(array, (a, b) -> b - a);

场景2：多条件排序（先长度，后字典序）

String[] words = {"apple", "banana", "cherry"};
Arrays.sort(words, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        // 第一条件：字符串长度
        int lenDiff = s1.length() - s2.length();
        if (lenDiff != 0) return lenDiff;
        
        // 第二条件：字典序
        return s1.compareTo(s2);
    }
});

场景3：对象数组按属性排序

class Student {
    String name;
    int score;
    // 构造方法、getter等...
}

Student[] students = {...};
Arrays.sort(students, (s1, s2) -> {
    // 按分数降序，分数相同按名字升序
    int scoreDiff = s2.score - s1.score;
    if (scoreDiff != 0) return scoreDiff;
    return s1.name.compareTo(s2.name);
});

五、高阶简化技巧（Java 8+）

1. 使用Lambda表达式

// 数位和排序简化版
Arrays.sort(numbers, (a, b) -> {
    int sumA = digitSum(a), sumB = digitSum(b);
    return (sumA != sumB) ? sumA - sumB : a - b;
});

2. 链式比较器（推荐！）

import java.util.Comparator;

Arrays.sort(numbers, 
    Comparator.comparingInt(this::digitSum) // 第一条件
             .thenComparingInt(n -> n)     // 第二条件
);

六、避坑指南

1. 数组类型必须为对象 ❌ int[] → ✅ Integer[]

2. 避免重复计算 对于复杂计算（如数位和），推荐预计算存储：

class NumberWithSum {
    int value;
    int digitSum;
    // 构造方法...
}

降序快捷写法 使用 Comparator.reversed()：

Arrays.sort(array, 
    Comparator.comparingInt(NumberWithSum::getDigitSum)
              .reversed() // 反转排序
);

七、验证工具

使用 Arrays.toString() 快速验证排序结果：

Integer[] testArr = {12, 3, 20};
Arrays.sort(testArr, yourComparator);
System.out.println(Arrays.toString(testArr)); // 输出排序后数组