目录

Comparable && Comparator的使用：

Comparable:

Comparator:

Arrays.sort()的使用:

升序排序：

 降序排序：

 自定义排序方法：

在日常的刷题或开发中，很多时候我们需要对数据进行排序，以达到我们的预期效果的作用。那么这些排序方法具体怎么实现和使用呢？本文就来好好缕一缕，总结一下这些方法：

Comparable && Comparator的使用：

Comparable:

当我们对类中的对象进行比较时，要保证对象时可比较的，这时我们就需要用到Comparable 或 Comparator接口，然后重写里面的compareTo()方法。假设我们有一个学生类，默认需要按照学生的年龄age排序，具体实现如下：

class Student implements Comparable{     private int id;     private int age;     private String name;      public Student(int id, int age, String name) {         this.id = id;         this.age = age;         this.name = name;     }      @Override     public int compareTo(Student o) {         //降序         //return o.age - this.age;         //升序         return this.age - o.age;     }      public int getId() {         return id;     }      public void setId(int id) {         this.id = id;     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      @Override     public String toString() {         return "Student{" +                 "id=" + id +                 ", age=" + age +                 ", name='" + name + '\'' +                 '}';     }  }

这里说一下  public int compareTo(Student o) 方法，它返回三种 int 类型的值： 负整数，零 ，正整数：

测试：

public class SortTest {     public static void main(String[] args) {         List list = new ArrayList<>();         list.add(new Student(103,25,"关羽"));         list.add(new Student(104,21,"张飞"));         list.add(new Student(108,18,"刘备"));         list.add(new Student(101,32,"袁绍"));         list.add(new Student(109,36,"赵云"));         list.add(new Student(103,16,"曹操"));         System.out.println("排序前:");         for(Student student : list){             System.out.println(student.toString());         }          System.out.println("默认排序后:");         Collections.sort(list);         for(Student student : list){             System.out.println(student.toString());         }     } } 

运行结果：

排序前: Student{id=103, age=25, name='关羽'} Student{id=104, age=21, name='张飞'} Student{id=108, age=18, name='刘备'} Student{id=101, age=32, name='袁绍'} Student{id=109, age=36, name='赵云'} Student{id=103, age=16, name='曹操'} 默认排序后: Student{id=103, age=16, name='曹操'} Student{id=108, age=18, name='刘备'} Student{id=104, age=21, name='张飞'} Student{id=103, age=25, name='关羽'} Student{id=101, age=32, name='袁绍'} Student{id=109, age=36, name='赵云'}  

Comparator:

Comparator的两种使用方法：

• Collections.sort(list,Comparator）;
• list.sort(Comparator);

这个时候需求又来了，默认是用 age 排序，但是有的时候需要用 id 来排序怎么办？ 这个时候比较器 ：Comparator 就排上用场了:

 //自定义排序：使用匿名内部类，实现Comparator接口，重写compare方法         Collections.sort(list, new Comparator() {             @Override             public int compare(Student o1, Student o2) {                 return o1.getId() - o2.getId();             }         });  //自定义排序2         list.sort(new Comparator() {             @Override             public int compare(Student o1, Student o2) {                 return o1.getId() - o2.getId();             }         });

compare(Student o1, Student o2) 方法的返回值跟 Comparable<> 接口的 compareTo(Student o) 方法返回值意思相同 

 运行结果：

自定义ID排序后: Student{id=101, age=32, name='袁绍'} Student{id=103, age=16, name='曹操'} Student{id=103, age=25, name='关羽'} Student{id=104, age=21, name='张飞'} Student{id=108, age=18, name='刘备'} Student{id=109, age=36, name='赵云'}

源码：

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List;  class Student implements Comparable{     private int id;     private int age;     private String name;      public Student(int id, int age, String name) {         this.id = id;         this.age = age;         this.name = name;     }      @Override     public int compareTo(Student o) {         //降序         //return o.age - this.age;         //升序         return this.age - o.age;     }      public int getId() {         return id;     }      public void setId(int id) {         this.id = id;     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      @Override     public String toString() {         return "Student{" +                 "id=" + id +                 ", age=" + age +                 ", name='" + name + '\'' +                 '}';     }  }  public class SortTest {     public static void main(String[] args) {         List list = new ArrayList<>();         list.add(new Student(103,25,"关羽"));         list.add(new Student(104,21,"张飞"));         list.add(new Student(108,18,"刘备"));         list.add(new Student(101,32,"袁绍"));         list.add(new Student(109,36,"赵云"));         list.add(new Student(103,16,"曹操"));         System.out.println("排序前:");         for(Student student : list){             System.out.println(student.toString());         }          System.out.println("默认排序后:");         Collections.sort(list);         for(Student student : list){             System.out.println(student.toString());         }         //自定义排序：使用匿名内部类，实现Comparator接口，重写compare方法         Collections.sort(list, new Comparator() {             @Override             public int compare(Student o1, Student o2) {                 return o1.getId() - o2.getId();             }         });         System.out.println("自定义ID排序后:");         for(Student student : list){             System.out.println(student.toString());         }         //自定义排序2         list.sort(new Comparator() {             @Override             public int compare(Student o1, Student o2) {                 return o1.getId() - o2.getId();             }         });      } } 

Arrays.sort()的使用:

升序排序：

1.正常排序一个数组：Arrays.sort(int [] a)；

我们看一下源码：

   public static void sort(int[] a) {         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);     }

本质上还是用到了快排，同时默认时从小到大进行排序的,具体实现：

public static void main(String[] args) {         //1.Arrays.sort(int[] a)  默认从小到达排序         int[] a =  new int[]{10,2,7,8,9,15,7};         System.out.println("默认时从小到大排序:");         Arrays.sort(a);         for(int x : a) System.out.print(x + " ");     }

运行结果：

默认时从小到大排序: 2 7 7 8 9 10 15 

 2.在一定区间内排序数组：Arrays.sort(int[] a, int fromIndex, int toIndex)

->规则为从fromIndex<= a数组

   public static void main(String[] args) {         //2.Arrays.sort(int[] a, int fromIndex, int toIndex)         //规则为从fromIndex<= a数组 

public static  void sort(T[] a,int fromIndex, int toIndex,  Comparator c)

 //2.java自带的Collections.reverseOrder() 降序排序数组         System.out.println("java自带的Collections.reverseOrder():");         Integer[] integers = new Integer[]{10, 293, 35, 24, 64, 56};         Arrays.sort(integers, Collections.reverseOrder());          for (Integer integer : integers) System.out.print(integer + " ");

java自带的Collections.reverseOrder(): 293 64 56 35 24 10 

自定义排序方法,需要实现java.util.Comparetor 接口中的compare方法 

//3.自定义排序方法,实现java.util.Comparetor 接口中的compare方法         Integer[] integers2 = new Integer[]{10, 293, 35, 24, 64, 56};          Arrays.sort(integers2, new Comparator() {             @Override             public int compare(Integer o1, Integer o2) {                 return o2.compareTo(o1);             }         });         System.out.println("自定义排序方法:");         for (int x : integers2) System.out.print(x + " ");

自定义排序方法: 293 64 56 35 24 10 

 //4.lambda表达式简化书写         Integer[] integers3 = new Integer[]{10, 293, 35, 24, 64, 56};         Arrays.sort(integers3, (o1, o2) -> {             return o2 - o1;         });         System.out.println("lambda表达式简化书写:");         for (int x : integers3) System.out.print(x + " ");

lambda表达式简化书写: 293 64 56 35 24 10 

import java.util.*; public class sortTest {     public static void main1(String[] args) {         //1.Arrays.sort(int[] a)  默认从小到达排序         int[] a =  new int[]{10,2,7,8,9,15,7};         System.out.println("默认时从小到大排序:");         Arrays.sort(a);         for(int x : a) System.out.print(x + " ");     }      public static void main2(String[] args) {         //2.Arrays.sort(int[] a, int fromIndex, int toIndex)         //规则为从fromIndex<= a数组 () {             @Override             public int compare(Integer o1, Integer o2) {                 return o2.compareTo(o1);             }         });         System.out.println("自定义排序方法:");         for (int x : integers2) System.out.print(x + " ");          System.out.println();         System.out.println("===================================");         //4.lambda表达式简化书写         Integer[] integers3 = new Integer[]{10, 293, 35, 24, 64, 56};         Arrays.sort(integers3, (o1, o2) -> {             return o2 - o1;         });         System.out.println("lambda表达式简化书写:");         for (int x : integers3) System.out.print(x + " ");       } } 

import java.util.Arrays; import java.util.Comparator;  class Cmp implements Comparator{      @Override     public int compare(int[] o1, int[] o2) {         return o1[0] - o2[0];     } } public class Sort {     public static void main123(String[] args) {         int[][] res = new int[][]{                 {3,6,7,8},                 {2,3,65,7},                 {1,4,5,78},                 {6,1,2,4}         };         //自定义排序二维数组，这里是按照每行第一个数字进行排序         Arrays.sort(res,new Cmp());         for(int i = 0;i < res.length;i++){             for(int j = 0;j < res[0].length;j++){                 System.out.print(res[i][j] + " ");             }             System.out.println();         }     } }