devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java Sort 方法的使用（包含Arrays.sort(),Collections.sort()以及Comparable，Comparator的使用 ）_java排序方法collections.sort comparator 多个字段

作者：不正经 | 2024-06-15 02:08:48

赞

踩

java排序方法collections.sort comparator 多个字段

目录

Comparable && Comparator的使用：

Comparable:

Comparator:

Arrays.sort()的使用:

升序排序：

 降序排序：

 自定义排序方法：

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

Comparable && Comparator的使用：

Comparable:

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

  1. class Student implements Comparable<Student>{
  2.     private int id;
  3.     private int age;
  4.     private String name;
  5.  
  6.     public Student(int id, int age, String name) {
  7.         this.id = id;
  8.         this.age = age;
  9.         this.name = name;
  10.     }
  11.  
  12.     @Override
  13.     public int compareTo(Student o) {
  14.         //降序
  15.         //return o.age - this.age;
  16.         //升序
  17.         return this.age - o.age;
  18.     }
  19.  
  20.     public int getId() {
  21.         return id;
  22.     }
  23.  
  24.     public void setId(int id) {
  25.         this.id = id;
  26.     }
  27.  
  28.     public int getAge() {
  29.         return age;
  30.     }
  31.  
  32.     public void setAge(int age) {
  33.         this.age = age;
  34.     }
  35.  
  36.     public String getName() {
  37.         return name;
  38.     }
  39.  
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  43.  
  44.     @Override
  45.     public String toString() {
  46.         return "Student{" +
  47.                 "id=" + id +
  48.                 ", age=" + age +
  49.                 ", name='" + name + '\'' +
  50.                 '}';
  51.     }
  52.  
  53. }

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

返回值含义
正整数当前对象的值 > 比较对象的值，升序排序
零当前对象的值 =  比较对象的值，不变
负整数当前对象的值 < 比较对象的值,降序排序

测试：

  1. public class SortTest {
  2.     public static void main(String[] args) {
  3.         List<Student> list = new ArrayList<>();
  4.         list.add(new Student(103,25,"关羽"));
  5.         list.add(new Student(104,21,"张飞"));
  6.         list.add(new Student(108,18,"刘备"));
  7.         list.add(new Student(101,32,"袁绍"));
  8.         list.add(new Student(109,36,"赵云"));
  9.         list.add(new Student(103,16,"曹操"));
  10.         System.out.println("排序前:");
  11.         for(Student student : list){
  12.             System.out.println(student.toString());
  13.         }
  14.  
  15.         System.out.println("默认排序后:");
  16.         Collections.sort(list);
  17.         for(Student student : list){
  18.             System.out.println(student.toString());
  19.         }
  20.     }
  21. }

运行结果：

  1. 排序前:
  2. Student{id=103, age=25, name='关羽'}
  3. Student{id=104, age=21, name='张飞'}
  4. Student{id=108, age=18, name='刘备'}
  5. Student{id=101, age=32, name='袁绍'}
  6. Student{id=109, age=36, name='赵云'}
  7. Student{id=103, age=16, name='曹操'}
  8. 默认排序后:
  9. Student{id=103, age=16, name='曹操'}
  10. Student{id=108, age=18, name='刘备'}
  11. Student{id=104, age=21, name='张飞'}
  12. Student{id=103, age=25, name='关羽'}
  13. Student{id=101, age=32, name='袁绍'}
  14. Student{id=109, age=36, name='赵云'}
  15.

Comparator:

Comparator的两种使用方法：

  • Collections.sort(list,Comparator<T>）;
  • list.sort(Comparator<T>);

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

  1.  //自定义排序：使用匿名内部类，实现Comparator接口，重写compare方法
  2.         Collections.sort(list, new Comparator<Student>() {
  3.             @Override
  4.             public int compare(Student o1, Student o2) {
  5.                 return o1.getId() - o2.getId();
  6.             }
  7.         });
  8.  //自定义排序2
  9.         list.sort(new Comparator<Student>() {
  10.             @Override
  11.             public int compare(Student o1, Student o2) {
  12.                 return o1.getId() - o2.getId();
  13.             }
  14.         });

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

 运行结果：

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

源码：

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.List;
  5.  
  6. class Student implements Comparable<Student>{
  7.     private int id;
  8.     private int age;
  9.     private String name;
  10.  
  11.     public Student(int id, int age, String name) {
  12.         this.id = id;
  13.         this.age = age;
  14.         this.name = name;
  15.     }
  16.  
  17.     @Override
  18.     public int compareTo(Student o) {
  19.         //降序
  20.         //return o.age - this.age;
  21.         //升序
  22.         return this.age - o.age;
  23.     }
  24.  
  25.     public int getId() {
  26.         return id;
  27.     }
  28.  
  29.     public void setId(int id) {
  30.         this.id = id;
  31.     }
  32.  
  33.     public int getAge() {
  34.         return age;
  35.     }
  36.  
  37.     public void setAge(int age) {
  38.         this.age = age;
  39.     }
  40.  
  41.     public String getName() {
  42.         return name;
  43.     }
  44.  
  45.     public void setName(String name) {
  46.         this.name = name;
  47.     }
  48.  
  49.     @Override
  50.     public String toString() {
  51.         return "Student{" +
  52.                 "id=" + id +
  53.                 ", age=" + age +
  54.                 ", name='" + name + '\'' +
  55.                 '}';
  56.     }
  57.  
  58. }
  59.  
  60. public class SortTest {
  61.     public static void main(String[] args) {
  62.         List<Student> list = new ArrayList<>();
  63.         list.add(new Student(103,25,"关羽"));
  64.         list.add(new Student(104,21,"张飞"));
  65.         list.add(new Student(108,18,"刘备"));
  66.         list.add(new Student(101,32,"袁绍"));
  67.         list.add(new Student(109,36,"赵云"));
  68.         list.add(new Student(103,16,"曹操"));
  69.         System.out.println("排序前:");
  70.         for(Student student : list){
  71.             System.out.println(student.toString());
  72.         }
  73.  
  74.         System.out.println("默认排序后:");
  75.         Collections.sort(list);
  76.         for(Student student : list){
  77.             System.out.println(student.toString());
  78.         }
  79.         //自定义排序：使用匿名内部类，实现Comparator接口，重写compare方法
  80.         Collections.sort(list, new Comparator<Student>() {
  81.             @Override
  82.             public int compare(Student o1, Student o2) {
  83.                 return o1.getId() - o2.getId();
  84.             }
  85.         });
  86.         System.out.println("自定义ID排序后:");
  87.         for(Student student : list){
  88.             System.out.println(student.toString());
  89.         }
  90.         //自定义排序2
  91.         list.sort(new Comparator<Student>() {
  92.             @Override
  93.             public int compare(Student o1, Student o2) {
  94.                 return o1.getId() - o2.getId();
  95.             }
  96.         });
  97.  
  98.     }
  99. }

Arrays.sort()的使用:

升序排序：

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

我们看一下源码：

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

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

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

运行结果：

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

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

->规则为从fromIndex<= a数组 <toIndex，左闭右开

  1.    public static void main(String[] args) {
  2.         //2.Arrays.sort(int[] a, int fromIndex, int toIndex)
  3.         //规则为从fromIndex<= a数组 <toIndex
  4.         int[] a = new int[]{2,5,4,1,19,3,2};
  5.         Arrays.sort(a,1,4);
  6.         for(int x : a) System.out.print(x + " ");
  7.     }

 降序排序：

实现方法：Collections.reverseOrder()

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

要实现降序排序，得通过包装类型的数组来实现，基本数据类型数组是不行的：

正确用法：

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

 运行结果：

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

 自定义排序方法：

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

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

运行结果：

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

 同时，我们可以用lambda表达是简化书写：

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

运行结果：

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

源码：

  1. import java.util.*;
  2. public class sortTest {
  3.     public static void main1(String[] args) {
  4.         //1.Arrays.sort(int[] a)  默认从小到达排序
  5.         int[] a =  new int[]{10,2,7,8,9,15,7};
  6.         System.out.println("默认时从小到大排序:");
  7.         Arrays.sort(a);
  8.         for(int x : a) System.out.print(x + " ");
  9.     }
  10.  
  11.     public static void main2(String[] args) {
  12.         //2.Arrays.sort(int[] a, int fromIndex, int toIndex)
  13.         //规则为从fromIndex<= a数组 <toIndex
  14.         int[] a = new int[]{2,5,4,1,19,3,2};
  15.         Arrays.sort(a,1,4);
  16.         for(int x : a) System.out.print(x + " ");
  17.     }
  18.  
  19.     public static void main3(String[] args) {
  20.        /* //1.实现降序排序，基本的数据类型数组是不行的
  21.         int[] a = new int[]{10,293,35,24,64,56};
  22.         Arrays.sort(a,Collections.reverseOrder());
  23.         for(int x : a) System.out.println(x + " ");*/
  24.  
  25.         //2.java自带的Collections.reverseOrder() 降序排序数组
  26.         System.out.println("java自带的Collections.reverseOrder():");
  27.         Integer[] integers = new Integer[]{10, 293, 35, 24, 64, 56};
  28.         Arrays.sort(integers, Collections.reverseOrder());
  29.  
  30.         for (Integer integer : integers) System.out.print(integer + " ");
  31.  
  32.         System.out.println();
  33.         System.out.println("===================================");
  34.         //3.自定义排序方法,实现java.util.Comparetor 接口中的compare方法
  35.         Integer[] integers2 = new Integer[]{10, 293, 35, 24, 64, 56};
  36.  
  37.         Arrays.sort(integers2, new Comparator<Integer>() {
  38.             @Override
  39.             public int compare(Integer o1, Integer o2) {
  40.                 return o2.compareTo(o1);
  41.             }
  42.         });
  43.         System.out.println("自定义排序方法:");
  44.         for (int x : integers2) System.out.print(x + " ");
  45.  
  46.         System.out.println();
  47.         System.out.println("===================================");
  48.         //4.lambda表达式简化书写
  49.         Integer[] integers3 = new Integer[]{10, 293, 35, 24, 64, 56};
  50.         Arrays.sort(integers3, (o1, o2) -> {
  51.             return o2 - o1;
  52.         });
  53.         System.out.println("lambda表达式简化书写:");
  54.         for (int x : integers3) System.out.print(x + " ");
  55.  
  56.  
  57.     }
  58. }

 补充，二维数组的排序：通过实现Comparator接口来自定义排序二维数组，以下面为例：

  1. import java.util.Arrays;
  2. import java.util.Comparator;
  3.  
  4. class Cmp implements Comparator<int[]>{
  5.  
  6.     @Override
  7.     public int compare(int[] o1, int[] o2) {
  8.         return o1[0] - o2[0];
  9.     }
  10. }
  11. public class Sort {
  12.     public static void main123(String[] args) {
  13.         int[][] res = new int[][]{
  14.                 {3,6,7,8},
  15.                 {2,3,65,7},
  16.                 {1,4,5,78},
  17.                 {6,1,2,4}
  18.         };
  19.         //自定义排序二维数组，这里是按照每行第一个数字进行排序
  20.         Arrays.sort(res,new Cmp());
  21.         for(int i = 0;i < res.length;i++){
  22.             for(int j = 0;j < res[0].length;j++){
  23.                 System.out.print(res[i][j] + " ");
  24.             }
  25.             System.out.println();
  26.         }
  27.     }
  28. }

运行结果：

好啦~本文到这里也是接近尾声了，希望有帮助到你，整理不易，希望多多三联支持呀~

结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/720452
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号