java中的Arrays.sort（）排序方法

灰太狼 2024-03-22 20:18 110阅读 0赞

**目录**

一、方法重载

二、注意事项

三、举例

（1）对于基本数据类型的数组，排序时会按照升序排序；

（2）对对象数组进行排序

--------------------

Java中的`Arrays.sort()`方法是一种内置的排序方法，用于对数组进行排序。这是一个来自`java.util.Arrays`类的静态方法，用于对所有的基本数据类型对象数组以及对象数组进行排序。排序的默认顺序是升序。

## 一、方法重载 ##

`Arrays.sort()`方法有许多重载版本，可以接受不同类型的输入，并对它们进行排序。以下是一些常见的重载版本：

*  `Arrays.sort(byte[] a)`: 对字节型数组进行排序
 *  `Arrays.sort(char[] a)`: 对字符型数组进行排序
 *  `Arrays.sort(double[] a)`: 对双精度浮点型数组进行排序
 *  `Arrays.sort(float[] a)`: 对浮点型数组进行排序
 *  `Arrays.sort(int[] a)`: 对整型数组进行排序
 *  `Arrays.sort(long[] a)`: 对长整型数组进行排序
 *  `Arrays.sort(short[] a)`: 对短整型数组进行排序
 *  `Arrays.sort(Object[] a)`: 对对象数组进行排序，此方法要求数组中的对象必须实现了`Comparable`接口
 *  `Arrays.sort(T[] a, Comparator<? super T> c)`: 对对象数组进行排序，使用一个定制的`Comparator`对象来比较数组中的元素

## 二、注意事项 ##

1.  对于对象数组，如果使用默认的`Arrays.sort(Object[] a)`方法进行排序，那么数组中的对象必须实现了`Comparable`接口。如果对象没有实现这个接口，那么在运行时会抛出`ClassCastException`。
2.  `Arrays.sort(T[] a, Comparator<? super T> c)`这个版本的方法允许你传入一个`Comparator`对象来自定义排序的规则。如果传入的`Comparator`对象为`null`，那么此方法将会使用元素的自然顺序进行排序。
3.  对于对象数组的排序，`Arrays.sort()`方法使用的是稳定的排序算法，这意味着等值的元素在排序后会保持他们原有的相对位置。
4.  `Arrays.sort()`方法的时间复杂性为O(n log n)。
5.  `Arrays.sort()`方法会对输入的数组进行直接排序，也就是说，它会改变输入数组的元素顺序。如果不希望改变原数组的元素顺序，那么在排序前需要先对数组进行复制。

## 三、举例 ##

### （1）对于基本数据类型的数组，排序时会按照升序排序； ###

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    Arrays.sort(arr); // 对数组进行排序
    
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
    }

输出结果：

1 1 2 3 3 4 5 5 5 6 9

ps：`Arrays.sort()` 方法使用的是快速排序算法和归并排序算法，具体使用哪一种算法取决于数组的大小和类型。当数组长度小于 `Arrays.MIN_ARRAY_SORT_GRAN` 时，使用插入排序算法对其进行排序。

### （2）对对象数组进行排序 ###

可以通过实现 `Comparator` 接口来指定比较器对象。`Comparator` 接口需要实现 `compare()` 方法，该方法接受两个对象作为参数，并返回一个整数值，用于表示这两个对象的大小关系。如果返回的值为负数，则表示第一个对象小于第二个对象，为正序；如果返回的值为正数，则表示第一个对象大于第二个对象，为逆序；如果返回的值为0，则表示两个对象相等。

import java.util.*;
    
    class Person {
        private String name;
        private int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    }
    
    class PersonAgeComparator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getAge() - o2.getAge();
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Person[] people = {
                    new Person("Alice", 25),
                    new Person("Bob", 20),
                    new Person("Charlie", 30)
            };
    
            Arrays.sort(people, new PersonAgeComparator());
    
            for (Person p : people) {
                System.out.println(p.getName() + " " + p.getAge());
            }
        }
    }

输出结果

Bob 20
    Alice 25
    Charlie 30

在该示例中，定义了一个 `Person` 类，包含两个属性 `name` 和 `age`。我们按照年龄对 `Person` 对象数组进行排序，创建了一个 `PersonAgeComparator` 类，实现了 `Comparator` 接口，并重写了 `compare()` 方法。在 `main()` 方法中，调用 `Arrays.sort()` 方法，并入 `PersonAgeComparator` 对象，来对 `Person` 对象数组进行排序。