JAVA数组的自定义排序你真的会了吗？

在Java中，数组是一种非常常用的数据结构。默认情况下，Java提供了对数组进行排序的方法，比如Arrays.sort()，但这种方式通常只适用于基本类型数组或实现了Comparable接口的对象数组。如果你想对数组进行自定义排序，比如按照某种特定的规则排序，你可以使用Arrays.sort()方法的另一个重载版本，或者使用Comparator接口来实现。

1. 使用Arrays.sort()进行自定义排序

Arrays.sort()方法的另一个重载版本允许你传入一个Comparator对象，用来指定排序的规则。Comparator是一个函数式接口，你可以使用Lambda表达式或匿名内部类来实现它。

示例1：使用Lambda表达式自定义排序

假设我们有一个字符串数组，我们希望按照字符串的长度进行排序：

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

public class CustomSortExample {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "kiwi", "orange", "grape"};

        // 使用Lambda表达式按字符串长度排序
        Arrays.sort(words, (a, b) -> a.length() - b.length());

        // 打印排序后的数组
        System.out.println(Arrays.toString(words));
    }
}

在这个例子中，(a, b) -> a.length() - b.length()是一个Lambda表达式，它实现了Comparator接口，a.length() - b.length()表示按照字符串的长度从小到大排序。

示例2：使用匿名内部类自定义排序

如果你不想使用Lambda表达式，也可以使用匿名内部类来实现：

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

public class CustomSortExample {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "kiwi", "orange", "grape"};

        // 使用匿名内部类按字符串长度排序
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.length() - b.length();
            }
        });

        // 打印排序后的数组
        System.out.println(Arrays.toString(words));
    }
}

这个例子中，我们使用了匿名内部类来实现Comparator接口，并在compare方法中定义了排序规则。

2. 自定义对象的排序

如果你有一个自定义对象的数组，并且想按照对象的某个属性进行排序，你同样可以使用Comparator来实现。

示例3：自定义对象数组的排序

假设我们有一个Person类：

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

我们想按照Person对象的年龄进行排序：

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

public class CustomSortExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 25),
            new Person("Bob", 20),
            new Person("Charlie", 30)
        };

        // 使用Lambda表达式按年龄排序
        Arrays.sort(people, (a, b) -> a.age - b.age);

        // 打印排序后的数组
        System.out.println(Arrays.toString(people));
    }
}

在这个例子中，我们按照Person对象的age属性进行排序。

示例4：使用Comparator.comparing()方法

Java 8引入了Comparator.comparing()方法，它可以使代码更加简洁：

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

public class CustomSortExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 25),
            new Person("Bob", 20),
            new Person("Charlie", 30)
        };

        // 使用Comparator.comparing按年龄排序
        Arrays.sort(people, Comparator.comparing(p -> p.age));

        // 打印排序后的数组
        System.out.println(Arrays.toString(people));
    }
}

Comparator.comparing()方法可以接受一个函数式接口，它从对象中提取一个可比较的键（比如age），并按照这个键进行排序。

3. 多条件排序

有时候你可能需要按照多个条件进行排序，比如先按年龄排序，如果年龄相同再按姓名排序。

示例5：多条件排序

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

public class CustomSortExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 25),
            new Person("Bob", 20),
            new Person("Charlie", 30),
            new Person("David", 25)
        };

        // 先按年龄排序，如果年龄相同再按姓名排序
        Arrays.sort(people, Comparator.comparingInt(Person::getAge)
                                      .thenComparing(Person::getName));

        // 打印排序后的数组
        System.out.println(Arrays.toString(people));
    }
}

在这个例子中，我们使用Comparator.comparingInt()按年龄排序，如果年龄相同，再使用thenComparing()按姓名排序。

4. 降序排序

如果你想进行降序排序，可以使用Comparator.reverseOrder()或者直接在Comparator中反转比较的结果。

示例6：降序排序

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

public class CustomSortExample {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "kiwi", "orange", "grape"};

        // 使用Lambda表达式按字符串长度降序排序
        Arrays.sort(words, (a, b) -> b.length() - a.length());

        // 打印排序后的数组
        System.out.println(Arrays.toString(words));
    }
}

在这个例子中，我们通过b.length() - a.length()实现了降序排序。

示例7：使用Comparator.reverseOrder()进行降序排序

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

public class CustomSortExample {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "kiwi", "orange", "grape"};

        // 使用Comparator.reverseOrder()进行降序排序
        Arrays.sort(words, Comparator.reverseOrder());

        // 打印排序后的数组
        System.out.println(Arrays.toString(words));
    }
}

Comparator.reverseOrder()会反转默认的排序顺序。

5. 总结

通过使用Arrays.sort()方法和Comparator接口，你可以轻松地对数组进行自定义排序。无论是基本类型数组、字符串数组还是自定义对象数组，都可以使用Comparator来实现复杂的排序逻辑。Java 8引入的Lambda表达式和Comparator.comparing()等方法使得代码更加简洁和易读。

希望这篇教程能帮助你更好地理解和使用Java中的数组自定义排序。如果你有任何问题或需要进一步的帮助，请随时提问！