Arrays.sort(T[], Comparator < ? super T > c) 是用来对用户自定义的对象数组排序功能的。Java 官方文档简单描述了它的作用，但不足以让我们深刻理解。为了更深入地理解它，这篇文章将梳理相关的关键点。

1、简单实例：如何使用Arrays.sort()

通过阅读下面代码，你能快速正确了解这个方法的用途。Comparator（比较器）用于根据Dogs的size比较其大小，并作为sort方法的参数。

1. import java.util.Arrays;
   
2. import java.util.Comparator;
   
3. 
   
4. class Dog{
   
5.     int size;   
   
6.     public Dog(int s){
   
7.         size = s;
   
8.     }
   
9. }
   
10. 
    
11. class DogSizeComparator implements Comparator<Dog>{
    
12. 
    
13.     @Override
    
14.     public int compare(Dog o1, Dog o2) {
    
15.         return o1.size - o2.size;
    
16.     }
    
17. }
    
18. 
    
19. public class ArraySort {
    
20. 
    
21.     public static void main(String[] args) {
    
22.         Dog d1 = new Dog(2);
    
23.         Dog d2 = new Dog(1);
    
24.         Dog d3 = new Dog(3);
    
25. 
    
26.         Dog[] dogArray = {d1, d2, d3};
    
27.         printDogs(dogArray);
    
28. 
    
29.         Arrays.sort(dogArray, new DogSizeComparator());
    
30.         printDogs(dogArray);
    
31.     }
    
32. 
    
33.     public static void printDogs(Dog[] dogs){
    
34.         for(Dog d: dogs)
    
35.             System.out.print(d.size + " " );
    
36. 
    
37.         System.out.println();
    
38.     }
    
39. }

复制代码

输出：

1. 2 1 3
   
2. 1 2 3

复制代码

2、策略模式的使用这是运用策略模式的一个很好的场景，为什么策略模式对于这种场景非常适用？简单来说，策略模式使不同的算法在运行时得以选择。在这个例子中，通过传递不同的Comparator，可以选择不同的算法。基于上例，现在假设你有一个Comparator，用weight来代替size来比较Dogs。你可以简单创建一个新的Comprator如下：

1. class Dog{
   
2.     int size;
   
3.     int weight;
   
4. 
   
5.     public Dog(int s, int w){
   
6.         size = s;
   
7.         weight = w;
   
8.     }
   
9. }
   
10. 
    
11. class DogSizeComparator implements Comparator<Dog>{
    
12. 
    
13.     @Override
    
14.     public int compare(Dog o1, Dog o2) {
    
15.         return o1.size - o2.size;
    
16.     }
    
17. }
    
18. 
    
19. class DogWeightComparator implements Comparator<Dog>{
    
20. 
    
21.     @Override
    
22.     public int compare(Dog o1, Dog o2) {
    
23.         return o1.weight - o2.weight;
    
24.     }
    
25. }
    
26. 
    
27. public class ArraySort {
    
28. 
    
29.     public static void main(String[] args) {
    
30.         Dog d1 = new Dog(2, 50);
    
31.         Dog d2 = new Dog(1, 30);
    
32.         Dog d3 = new Dog(3, 40);
    
33. 
    
34.         Dog[] dogArray = {d1, d2, d3};
    
35.         printDogs(dogArray);
    
36. 
    
37.         Arrays.sort(dogArray, new DogSizeComparator());
    
38.         printDogs(dogArray);
    
39. 
    
40.         Arrays.sort(dogArray, new DogWeightComparator());   
    
41.         printDogs(dogArray);
    
42.     }
    
43. 
    
44.     public static void printDogs(Dog[] dogs){
    
45.         for(Dog d: dogs)
    
46.             System.out.print("size="+d.size + " weight=" + d.weight + " ");
    
47. 
    
48.         System.out.println();
    
49.     }
    
50. }

复制代码

输出：

1. size=2 weight=50 size=1 weight=30 size=3 weight=40
   
2. size=1 weight=30 size=2 weight=50 size=3 weight=40
   
3. size=1 weight=30 size=3 weight=40 size=2 weight=50

复制代码

Comparator仅仅是一个接口，任何实现了Comparator在运行时都可以被使用，这是策略模式的核心理念。3、为什么使用“super”很显然，如果”Comparator<T>c”作为参数，但是第二个参数是”Comparator< ? super T > c”，使用<? super T>意味着类型可以是T或者是它的超类。为什么允许超类型呢？答案是：这种方式允许所有子类使用同一个comparator。看看下面这个例子一目了然。

1. import java.util.Arrays;
   
2. import java.util.Comparator;
   
3. 
   
4. class Animal{
   
5.     int size;
   
6. }
   
7. 
   
8. class Dog extends Animal{
   
9.     public Dog(int s){
   
10.         size = s;
    
11.     }
    
12. }
    
13. 
    
14. class Cat extends Animal{
    
15.     public Cat(int s){
    
16.         size  = s;
    
17.     }
    
18. }
    
19. 
    
20. class AnimalSizeComparator implements Comparator<Animal>{
    
21. 
    
22.     @Override
    
23.     public int compare(Animal o1, Animal o2) {
    
24.         return o1.size - o2.size;
    
25.     }
    
26.     //in this way, all sub classes of Animal can use this comparator.
    
27. }
    
28. 
    
29. public class ArraySort {
    
30. 
    
31.     public static void main(String[] args) {
    
32.         Dog d1 = new Dog(2);
    
33.         Dog d2 = new Dog(1);
    
34.         Dog d3 = new Dog(3);
    
35. 
    
36.         Dog[] dogArray = {d1, d2, d3};
    
37.         printDogs(dogArray);
    
38. 
    
39.         Arrays.sort(dogArray, new AnimalSizeComparator());  
    
40.         printDogs(dogArray);
    
41. 
    
42.         System.out.println();
    
43. 
    
44.         //when you have an array of Cat, same Comparator can be used.
    
45.         Cat c1 = new Cat(2);
    
46.         Cat c2 = new Cat(1);
    
47.         Cat c3 = new Cat(3);
    
48. 
    
49.         Cat[] catArray = {c1, c2, c3};
    
50.         printDogs(catArray);
    
51. 
    
52.         Arrays.sort(catArray, new AnimalSizeComparator());  
    
53.         printDogs(catArray);
    
54.     }
    
55. 
    
56.     public static void printDogs(Animal[] animals){
    
57.         for(Animal a: animals)
    
58.             System.out.print("size="+a.size + " ");
    
59.         System.out.println();
    
60.     }
    
61. }

复制代码

输出：

1. size=2 size=1 size=3
   
2. size=1 size=2 size=3
   
3. 
   
4. size=2 size=1 size=3
   
5. size=1 size=2 size=3

复制代码

4、总结总的来说，从Arrays.sort()中你应该了解到：

• generic(范型)——super
• 策略模式
• 归并排序——nlog(n)时间复杂度
• java.util.Collections.sort(List<T>list, Comparator<?super T> c)类似于Arrays.sort
  

涨姿势了，谢谢分享

学习了！

刚学  有点看不懂 慢慢学吧  谢谢楼主分享

谢谢分享

感谢分享