【JAVA】Collections.sort()方法详解

一、简介

Collections.sort() 是 Java 集合框架（Java Collections Framework）中的一个静态方法，用于对列表（List）中的元素进行排序。此方法利用了 Java 的泛型机制，可以很方便地对各种类型的列表进行排序。

• 源码方法体：
  
• 参数 list：需要排序的列表。列表中的元素必须实现了 Comparable 接口，以便能够比较它们的大小。

二、使用示例

1、普通使用

假设你有一个 Integer 类型的列表，你可以使用 Collections.sort() 方法对它进行排序：

	import java.util.ArrayList;  
	import java.util.Collections;  
	import java.util.List;  
	  
	public class SortExample {  
	    public static void main(String[] args) {  
	        List<Integer> numbers = new ArrayList<>();  
	        numbers.add(3);  
	        numbers.add(1);  
	        numbers.add(4);  
	        numbers.add(1);  
	        numbers.add(5);  
	        numbers.add(9);  
	        numbers.add(2);  
	        numbers.add(6);  
	        numbers.add(5);  
	        numbers.add(3);  
	        numbers.add(5);  
	  
	        System.out.println("Before sorting:");  
	        for (int number : numbers) {  
	            System.out.print(number + " ");  
	        }  
	        System.out.println();  
	  
	        Collections.sort(numbers);  
	  
	        System.out.println("After sorting:");  
	        for (int number : numbers) {  
	            System.out.print(number + " ");  
	        }  
	    }  
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

输出：
1

	Before sorting:  
	3 1 4 1 5 9 2 6 5 3 5   
	After sorting:  
	1 1 2 3 3 4 5 5 5 6 9
1
2
3
4

2、进阶示例

如果列表中的元素没有实现 Comparable 接口，你不能直接使用 Collections.sort() 方法的默认版本，因为该方法需要列表中的元素能够相互比较。但是，你可以通过实现 Comparator 接口来定义元素之间的比较逻辑，并使用 Collections.sort() 的另一个版本，它接受一个 Comparator 参数。

Comparator 接口定义了一个 compare(T o1, T o2) 方法，你需要在这个方法中定义如何比较两个元素。

以下是一个示例，展示了如何对一个包含自定义对象的列表进行排序，这些对象没有实现 Comparable 接口：

	public class SortWithComparatorExample {  
	    public static void main(String[] args) {  
	        List<Person> people = new ArrayList<>();  
	        people.add(new Person("Alice", 30));  
	        people.add(new Person("Bob", 20));  
	        people.add(new Person("Charlie", 25));  
	  
	        // 使用自定义的 Comparator 进行排序  
	        Collections.sort(people, new Comparator<Person>() {  
	            @Override  
	            public int compare(Person p1, Person p2) {  
	                // 按照年龄升序排序  
	                return p1.getAge() - p2.getAge();  
	            }  
	        });  
	  
	        // 输出排序后的列表  
	        for (Person person : people) {  
	            System.out.println(person);  
	        }  
	    }  
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在上面的代码中，我们定义了一个 Person 类，它包含 name 和 age 两个属性。我们创建了一个 Person 对象的列表，并使用 Collections.sort() 方法和一个自定义的 Comparator 来按照年龄对列表进行排序。

在Comparator接口的compare方法中，返回值是一个整数，它表示了被比较的两个对象之间的相对顺序。这个返回值遵循以下约定：

• 如果返回值小于0（通常是负数），则表示第一个对象（o1）应该排在第二个对象（o2）之前。
• 如果返回值等于0，则表示两个对象是相等的，它们的顺序无关紧要。
• 如果返回值大于0（通常是正数），则表示第一个对象（o1）应该排在第二个对象（o2）之后。

这个返回值用于构建排序算法中的比较逻辑。排序算法会根据compare方法的返回值来决定列表中元素的最终位置。我们也可以根据对象中的值，通过返回值自己定义排序规则。

注意，在 compare 方法中，我们简单地返回了两个 Person 对象年龄的差值。在实际应用中，你可能需要处理更复杂的比较逻辑，并考虑使用 Integer.compare(int x, int y) 这样的方法来避免整数溢出的问题。

3、 lambda 表达式比较

此外，从 Java 8 开始，你还可以使用 lambda 表达式来更简洁地定义 Comparator：

Collections.sort(people, (p1, p2) -> p1.getAge() - p2.getAge());
1

或者，使用 List 接口的 sort 方法（如果列表是 ArrayList 或其他支持此方法的列表实现）：

people.sort((p1, p2) -> p1.getAge() - p2.getAge());
1

这些方法都允许你在不修改原始类的情况下对列表进行排序。

三、注意事项

列表中的元素必须实现 Comparable 接口。如果元素没有实现这个接口，那么在调用 Collections.sort() 方法时会抛出 ClassCastException。
Collections.sort() 方法使用了稳定的排序算法，即相等的元素在排序后的列表中的相对顺序与它们在原始列表中的相对顺序相同。
如果需要对列表进行自定义排序（例如，根据对象的某个特定属性进行排序），你可以实现自己的 Comparator，并使用 Collections.sort(List<T> list, Comparator<? super T> c) 方法进行排序。

四、性能

Collections.sort() 方法在内部使用了归并排序或 Timsort 算法，这些算法的时间复杂度通常是 O(n log n)，其中 n 是列表中元素的数量。这意味着对于大型列表，排序操作通常是相对高效的。然而，对于非常小的列表，使用插入排序可能会更快，但 Collections.sort() 并不保证在这种情况下使用插入排序。