世界杯预选赛亚洲区_高达世界杯 - fzxzyy.com

总结整理不易，如果对你有所帮助，不妨动手点个免费的赞哦，收藏关注不迷路[比心]~

目录

1. sort() 函数的基本原理

2. sort() 函数的用法

2.1 默认排序（升序）

2.2 局部排序

2.2 降序排序(逆序排序）

2.2.1 使用Collections.reverseOrder()方法进行逆序排序

2.2.2 使用Comparator.reversed()方法

2.2.3 匿名内部类

2.2.4 使用Lambda表达式进行逆序排序

2.3 自定义对象进行排序

2.4 Lambda 表达式简化Comparator的实现

2.4.1 基本的Lambda表达式

2.4.2 省略类型定义：

2.4.3 使用静态方法引用：

2.4.4 使用实例方法引用：

2.5 多级排序

2.6 并行排序

在 Java 编程中，sort() 函数是一个非常重要且常用的方法，用于对数组或集合进行排序操作。本文将深入探讨 sort() 函数的基本原理、以及其在实际应用中的多种用法。

1. sort() 函数的基本原理

Java中的sort()函数是一个高效的排序算法，其具体的实现原理取决于排序的数据类型和大小。在Java 7之前，Arrays类使用的是经典的快速排序算法。在Java 7及以后的版本中，Arrays类在排序小型数组时使用的是改进后的快速排序算法，而在排序大型数组时使用的是归并排序算法。

原理详情请看往期：一文让你深入理解java中sort() 方法的底层原理，Collections.sort，Arrays.sort_java sort的底层原理-CSDN博客

2. sort() 函数的用法

在 Java 中，sort() 函数可以用于对数组或集合进行排序，其用法略有不同。

2.1 默认排序（升序）

格式：

Arrays.sort(array);

Collections.sort(list);

例：

//对整型数组进行排序

int[] array = {5, 2, 9, 1, 3};

Arrays.sort(array);

System.out.println(Arrays.toString(array)); //输出：[1, 2, 3, 5, 9]

​

//对字符串数组进行排序

String[] names = {"John", "Alice", "Bob", "David"};

Arrays.sort(names);

System.out.println(Arrays.toString(names)); //输出：[Alice, Bob, David, John]

​

// 对列表进行排序

List list = new ArrayList<>();

list.add(5);

list.add(2);

list.add(9);

list.add(1);

list.add(3);

Collections.sort(list);

System.out.println(list); // 输出：[1, 2, 3, 5, 9]

2.2 局部排序

格式：

Arrays.sort(数组名,start,end);//注意左闭右开！！！[start,end)

例：

int[] array = {5, 2, 9, 1, 3};

//对数组的一部分内容进行排序（索引从1到4，包括1不包括4）

Arrays.sort(array, 1, 4);

System.out.println(Arrays.toString(array)); //输出：[5, 1, 2, 9, 3]

2.2 降序排序(逆序排序）

有时我们需要对数组或集合进行倒序排序，可以通过自定义比较器实现：

2.2.1 使用Collections.reverseOrder()方法进行逆序排序

//数组：

Integer[] arr = {3, 1, 4, 1, 5, 9};

Arrays.sort(arr, Collections.reverseOrder());// 输出：[9, 5, 4, 3, 1, 1]

Collections.sort(list, nameComparator.reversed());

//集合：

List list = Arrays.asList(3, 1, 4, 1, 5, 9);

Collections.sort(list, Collections.reverseOrder());

System.out.println(list); // 输出：[9, 5, 4, 3, 1, 1]

2.2.2 使用Comparator.reversed()方法

List list = Student.getStudentList();

Comparator nameComparator = (s1, s2) -> s1.getName().compareTo(s2.getName());

Collections.sort(list, nameComparator.reversed());

2.2.3 匿名内部类

Integer[] arr = {8, 9, 5, 2, 3, 6, 1, 0, 7, 4};

Arrays.sort(arr, new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return o1 - o2;

}

});

2.2.4 使用Lambda表达式进行逆序排序

Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};

Arrays.sort(arr, (o1, o2) -> o2 - o1);

2.3 自定义对象进行排序

//数组自定义对象排序

Person[] people = {new Person("Alice", 25), new Person("Bob", 20), new Person("Charlie", 30)};

Comparator byName = Comparator.comparing(Person::getName);//注：Person 类中需有getName()方法

Arrays.sort(people, byName); //按照姓名排序

​

// 集合自定义对象排序

List persons = new ArrayList<>();

persons.add(new Person("Alice", 25));

persons.add(new Person("Bob", 30));

persons.add(new Person("David", 20));

Comparator byName = Comparator.comparing(Person::getName);

Collections.sort(persons, byName); // 使用 Collections.sort() 对 List 进行排序

//匿名内部类

public static List compareTest(List arr) {

Collections.sort(arr, new Comparator() {

public int compare(People p1, People p2) {

int a = p1.age; //比较的是age

int b = p2.age;

return a < b ? -1 : a == b ? 0 : 1; //当ab返回1

}

});

2.4 Lambda 表达式简化Comparator的实现

自从 Java 8 引入了 Lambda 表达式，我们可以更加简洁地定义比较器：

2.4.1 基本的Lambda表达式

Comparator byName = (Developer o1, Developer o2) -> o1.getName().compareTo(o2.getName());

这里，我们创建了一个Comparator来比较两个Developer对象的名字。

2.4.2 省略类型定义：

humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));

在这个例子中，我们不需要指定h1和h2的类型，编译器会自动推断。

2.4.3 使用静态方法引用：

humans.sort(Human::compareByNameThenAge);

在这里我们使用了Human类的静态方法compareByNameThenAge作为Comparator。

2.4.4 使用实例方法引用：

Collections.sort(humans, Comparator.comparing(Human::getName));

2.5 多级排序

List listDevs = getDevelopers();

Comparator comparator = Comparator.comparing(Developer::getAge)

.thenComparing(Developer::getName);

listDevs.sort(comparator);

2.6 并行排序

Java 8引入了并行排序。如果你有一个非常大的数组，你可以使用Arrays.parallelSort()方法进行排序。这个方法会利用多核处理器的优势，将数组分成多个部分，然后并行地对每个部分进行排序，最后再将结果合并起来。

//例1：

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};

Arrays.parallelSort(arr);

System.out.println(Arrays.toString(arr)); // 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

//例2

List list = new ArrayList<>();

// 添加大量数据到列表中

list = list.parallelStream().sorted().collect(Collectors.toList());