【Java】Java数组排序详解：全面掌握Arrays.sort()的几种用法

在 Java 开发中，java.util.Arrays 类提供了许多实用工具，用于操作数组。其中，Arrays.sort() 方法是对数组进行排序的常用方法。本文将详细介绍 Arrays.sort() 的不同用法，包括基本类型数组、对象数组、多维数组和自定义比较器的排序。

---

🧑 博主简介：
现任阿里巴巴嵌入式技术专家，15年工作经验，深耕嵌入式+人工智能领域，精通嵌入式领域开发、技术管理、简历招聘面试。CSDN优质创作者，提供产品测评、学习辅导、简历面试辅导、毕设辅导、项目开发、C/C++/Java/Python/Linux/AI等方面的服务，如有需要请站内私信或者联系任意文章底部的的VX名片（ID：gylzbk）

💬 博主粉丝群介绍：① 群内初中生、高中生、本科生、研究生、博士生遍布，可互相学习，交流困惑。② 热榜top10的常客也在群里，也有数不清的万粉大佬，可以交流写作技巧，上榜经验，涨粉秘籍。③ 群内也有职场精英，大厂大佬，可交流技术、面试、找工作的经验。④ 进群免费赠送写作秘籍一份，助你由写作小白晋升为创作大佬。⑤ 进群赠送CSDN评论防封脚本，送真活跃粉丝，助你提升文章热度。有兴趣的加文末联系方式，备注自己的CSDN昵称，拉你进群，互相学习共同进步。

@TOC

排序基本类型数组

Arrays.sort() 可以对基本类型数组进行升序排序，包括 int、char、float、double 等。

示例代码：

import java.util.Arrays;

public class BasicTypeSort {
    public static void main(String[] args) {
        // 整数数组排序
        int[] intArray = {5, 2, 9, 1, 5, 6};
        Arrays.sort(intArray);
        System.out.println("Sorted int array: " + Arrays.toString(intArray));

        // 浮点数数组排序
        double[] doubleArray = {5.5, 2.2, 9.7, 1.8, 3.3};
        Arrays.sort(doubleArray);
        System.out.println("Sorted double array: " + Arrays.toString(doubleArray));

        // 字符数组排序
        char[] charArray = {'c', 'a', 'e', 'b', 'd'};
        Arrays.sort(charArray);
        System.out.println("Sorted char array: " + Arrays.toString(charArray));
    }
}

排序对象数组

Arrays.sort() 也可以对对象数组进行排序，但对象类型必须实现 Comparable 接口。

示例代码：

import java.util.Arrays;

class Person implements Comparable<Person> {
    String name;
    int age;

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

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;  // 按年龄升序排序
    }

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

public class ObjectArraySort {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        Arrays.sort(people);  // 按年龄排序
        System.out.println("Sorted person array: " + Arrays.toString(people));
    }
}

使用自定义比较器排序

如果对象类型没有实现 Comparable 接口或者需要按不同条件排序，可以使用 Comparator 自定义比较器。

示例代码：

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

class Person {
    String name;
    int age;

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

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

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

        // 按名字排序
        Comparator<Person> nameComparator = (p1, p2) -> p1.name.compareTo(p2.name);
        Arrays.sort(people, nameComparator);
        System.out.println("Sorted by name: " + Arrays.toString(people));

        // 按年龄排序
        Comparator<Person> ageComparator = (p1, p2) -> p1.age - p2.age;
        Arrays.sort(people, ageComparator);
        System.out.println("Sorted by age: " + Arrays.toString(people));
    }
}

排序多维数组

对于二维数组，可以通过 Comparator 对每行进行自定义排序。

示例代码：

import java.util.Arrays;

public class MultiDimensionalSort {
    public static void main(String[] args) {
        int[][] array = {
            {3, 9, 4},
            {2, 7, 5},
            {1, 8, 6}
        };

        // 按每行第一个元素排序
        Arrays.sort(array, (a, b) -> Integer.compare(a[0], b[0]));

        System.out.println("Sorted 2D array:");
        for (int[] row : array) {
            System.out.println(Arrays.toString(row));
        }
    }
}

部分排序

Arrays.sort() 支持对数组的部分进行排序，通过指定起始位置和结束位置。

示例代码：

import java.util.Arrays;

public class PartialSort {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 5, 6};
        Arrays.sort(array, 1, 4);  // 仅排序索引 1 到 3 的元素
        System.out.println("Partially sorted array: " + Arrays.toString(array));
    }
}

排序性能

Arrays.sort() 方法在采用 Dual-Pivot QuickSort 对原始类型数组进行排序时的效率较高。在排序对象数组时，改用 Timsort 算法，这两种算法都能提供稳定的排序性能。

示例代码：

import java.util.Arrays;
import java.util.Random;

public class SortPerformance {
    public static void main(String[] args) {
        int[] array = new int[1000000];
        Random rand = new Random();

        for (int i = 0; i < array.length; i++) {
            array[i] = rand.nextInt(1000000);
        }

        long startTime = System.nanoTime();
        Arrays.sort(array);
        long endTime = System.nanoTime();

        System.out.printf("Time taken to sort array of size %d: %d ns%n", array.length, (endTime - startTime));
    }
}

实例演示

我们将结合上述所有用法，创建一个示例程序进行演示：

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

public class ArraysSortDemo {

    public static void main(String[] args) {
        // 基本类型数组排序
        int[] intArray = {5, 2, 9, 1, 5, 6};
        Arrays.sort(intArray);
        System.out.println("Sorted int array: " + Arrays.toString(intArray));

        // 对象数组排序（实现 Comparable）
        Person[] peopleComparable = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        Arrays.sort(peopleComparable);
        System.out.println("Sorted comparable people array: " + Arrays.toString(peopleComparable));

        // 对象数组排序（自定义 Comparator）
        Person[] peopleComparator = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        Arrays.sort(peopleComparator, Comparator.comparingInt(Person::getAge));
        System.out.println("Sorted comparator people array: " + Arrays.toString(peopleComparator));

        // 二维数组排序
        int[][] twoDArray = {
            {3, 9, 4},
            {2, 7, 5},
            {1, 8, 6}
        };
        Arrays.sort(twoDArray, (a, b) -> Integer.compare(a[0], b[0]));
        System.out.println("Sorted 2D array:");
        for (int[] row : twoDArray) {
            System.out.println(Arrays.toString(row));
        }

        // 部分排序
        int[] partialArray = {5, 2, 9, 1, 5, 6};
        Arrays.sort(partialArray, 1, 4);
        System.out.println("Partially sorted array: " + Arrays.toString(partialArray));
    }

    static class Person implements Comparable<Person> {
        private String name;
        private int age;

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

        @Override
        public int compareTo(Person other) {
            return this.age - other.age;  // 按年龄升序排序
        }

        public int getAge() {
            return age;
        }

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

总结

Arrays.sort() 是 Java 中非常强大和灵活的数组排序方法。通过本文，你了解了如何对基本类型数组、对象数组进行排序，如何使用自定义比较器，以及如何排序多维数组和部分数组。