Arrays.sort() Collections.sort() 自定义排序

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量538 收藏 2
点赞数
分类专栏： JAVA学习总结 文章标签： java jdk 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21926717/article/details/120753486
版权

文章目录


Java的JDK中提供了强大的接口，其中关于自定义排序的方法主要有如下几类：

Arrays中sort方法

sort方法有很多的重载，实现了不同数据类型的排序和自定义排序；

基本数据类型的排序

基本数据类型的排序直接使用相应的方法sort(int[] a)，支持的数据类型数组包括：

  1. char[] a;
  2. byte[] a;
  3. short[] a;
  4. int[] a;
  5. long[] a;
  6. float[] a;
  7. double[] a;

默认为升序排序，自定义排序方式下面另说；

排序方式使用的都是快速排序的一个改动版：Dual-Pivot Quicksort，时间复杂度O(nlog(n));

以上方法都有一个相应的孪生兄弟，如上述方法sort(int[] a)的重载方法就是sort(int[] a, int fromIndex, int toIndex)，它的作用是指定需要排序的区间，区间为左闭右开：

public class BasicSort {
    public static void main(String[] args){
        int[] a = new int[]{5,4,6,3,7,2,8,1,9,0};
        System.out.println("排序前：" + Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序后：" + Arrays.toString(a));

        a = new int[]{5,4,6,3,7,2,8,1,9,0};
        System.out.println("自定义区间排序前：" + Arrays.toString(a));
        Arrays.sort(a, 0, 5);
        System.out.println("自定义区间排序后：" + Arrays.toString(a));
    }
}

排序前：[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]
排序后：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
自定义区间排序前：[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]
自定义区间排序后：[3, 4, 5, 6, 7, 2, 8, 1, 9, 0]

其中需要注意的是Float、Double类型各自使用了其类中内置定义的比较函数，如Float中规则为 -0.0f < 0.0f，Float.NaN == Float.NaN；

float[] b = new float[]{1.1f, 2.2f, 0.0f, -0.0f, Float.NaN, 1000f, Float.NEGATIVE_INFINITY, Float.NaN};
System.out.println("自定义区间排序前：" + Arrays.toString(b));
Arrays.sort(b);
System.out.println("自定义区间排序后：" + Arrays.toString(b));

自定义区间排序前：[1.1, 2.2, 0.0, -0.0, NaN, 1000.0, -Infinity, NaN]
自定义区间排序后：[-Infinity, -0.0, 0.0, 1.1, 2.2, 1000.0, NaN, NaN]

Object类型的排序

Object类型数据的排序需要实现Comparable接口并实现其中的compareTo方法；
主要是以下几种：

  1. 基本类型的包装类，其已经实现了Comparable接口；
  2. JDK中实现了Comparable接口的类，如String；
  3. 自定义类并实现接口Comparable；

下面代码中需要用到的学生类：

public class Student implements Comparable<Student>{
    public int id; // 学号，为了获取方便直接定义为public
    public int grade; // 分数
    public Student(int id, int grade) {
        this.id = id;
        this.grade = grade;
    }
    /**
     * 排序规则：
     * 分数高的排前面，分数相同的学号小的排前面
     * @param o
     * @return
     */
    @Override
    public int compareTo(Student o) {
        if(this.grade != o.grade){
            return o.grade - this.grade;
        }else{
            return this.id - o.id;
        }
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", grade=" + grade +
                '}';
    }
}

对对象列表排序：

public class CpmparableSort {
    public static void main(String[] args) {
        Student[] a = new Student[]{
                new Student(1001, 60),
                new Student(1002, 100),
                new Student(1000, 60)
        };
        System.out.println("排序前：" + Arrays.toString(a));
        Arrays.sort(a); // 使用实现Comparable接口定义的比较规则
        System.out.println("排序后：" + Arrays.toString(a));
    }
}

排序前：[Student{id=1001, grade=60}, Student{id=1002, grade=100}, Student{id=1000, grade=60}]
排序后：[Student{id=1000, grade=60}, Student{id=1001, grade=60}, Student{id=1002, grade=100}]

该排序是一个稳定的，自适应的，迭代归并的排序方式，实现基于TimSort，是一个基于插入排序和归并排序的自适应排序方式；

当然，它同样也有一个孪生的方法sort(Object[] a, int fromIndex, int toIndex)，对左闭右开区间的元素进行排序；

根据指定比较器对对象进行排序

public static void sort(T[] a, Comparator<? super T> c)，需要指定一个比较器Comparator，也就是对需要排序的元素指定排序规则；

如对二维数组排序，其中第二维只有两个元素，先按照第一个元素升序排序，第一个元素相等，按照第二个元素升序排序，也就是实现了多级排序；

public class ComparatorSort {
    public static void main(String[] args) {
        int[][] a = new int[][]{
                {0, 3}, {1, 5}, {7, 5},
                {1, 3}, {5, 6}, {9, 5}
        };
        System.out.println("排序前：");
        for(int i=0; i<a.length; ++i){
            System.out.println(Arrays.toString(a[i]));
        }
        /**
         * 自定义比较器
         * 二维数组，其中第二维只有两个元素，按前一个元素升序排序，前一个元素相同，则按后一个元素升序
         */
        Arrays.sort(a, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] != o2[0]){
                    return o1[0] - o2[0];
                }else{
                    return o1[1] - o2[1];
                }
            }
        });
        System.out.println("排序后：");
        for(int i=0; i<a.length; ++i){
            System.out.println(Arrays.toString(a[i]));
        }
    }
}

排序前：
[0, 3]
[1, 5]
[7, 5]
[1, 3]
[5, 6]
[9, 5]
排序后：
[0, 3]
[1, 3]
[1, 5]
[5, 6]
[7, 5]
[9, 5]

前面提到的基本类型，对元素的排序方式默认为升序，如果想要降序，则可以通过自定义排序器指定排序规则；

Object类型，若是没有实现Comparable接口或已经实现了Comparable接口但想要一种新的排序方式，就可以自定义比较器Comparator，实现自定义的排序；

public class ComparatorSort1 {

    public static void main(String[] args) {
        Student[] a = new Student[]{
                new Student(1001, 60),
                new Student(1002, 100),
                new Student(1000, 60)
        };
        System.out.println("排序前：" + Arrays.toString(a));
        /**
         * 自定义比较器Comparator
         * 按照学号升序，学号相同，按成绩升序
         */
        Arrays.sort(a, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.id != o2.id){
                    return o1.id - o2.id;
                }else{
                    return o1.grade - o2.grade;
                }
            }
        });
        System.out.println("排序后：" + Arrays.toString(a));
    }
}

排序前：[Student{id=1001, grade=60}, Student{id=1002, grade=100}, Student{id=1000, grade=60}]
排序后：[Student{id=1000, grade=60}, Student{id=1001, grade=60}, Student{id=1002, grade=100}]

当然，这个方法也有一个孪生兄弟，也就是可以指定排序区间，同上。

Collections中sort方法

Collections中提供的方法，包括sort方法，都是为了给Collection接口下的各类使用的；包括两种：

  1. 类已经实现了Comparable接口：public static <T extends Comparable<? super T>> void sort(List list)
  2. 自定义比较器Comparator：public static void sort(List list, Comparator<? super T> c)

两者的用法和上述的基本相同，只不过对象用于集合；这两种方式都是基于List接口中方法default void sort(Comparator<? super E> c)，其基于TimSort排序；

void sort(List list)

public static <T extends Comparable<? super T>> void sort(List list)

这种方式一定需要List中元素已经实现了Comparable接口，如基本数据类型的包装类，String等类，若是自定义类，则需要实现Comparable接口自定义排序方法；

void sort(List list, Comparator<? super T> c)

public static void sort(List list, Comparator<? super T> c)

这种方法使用时需要自定义比较器Comparator；

例：

public class CustomSort {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5,4,6,3,7,2,8,1,9,0);
        System.out.println("排序前：" + list);
        Collections.sort(list);
        System.out.println("排序后：" + list);

        List<Student> stuList = Arrays.asList(
                new Student(1001, 60),
                new Student(1002, 100),
                new Student(1000, 60)
        );
        System.out.println("排序前：" + stuList);
        Collections.sort(stuList);
        System.out.println("排序后：" + stuList);

        System.out.println("排序前：" + stuList);
        Collections.sort(stuList, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.id != o2.id){
                    return o1.id - o2.id;
                }else{
                    return o1.grade - o2.grade;
                }
            }
        });
        System.out.println("排序后：" + stuList);
    }
}

排序前：[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]
排序后：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
排序前：[Student{id=1001, grade=60}, Student{id=1002, grade=100}, Student{id=1000, grade=60}]
排序后：[Student{id=1002, grade=100}, Student{id=1000, grade=60}, Student{id=1001, grade=60}]
排序前：[Student{id=1002, grade=100}, Student{id=1000, grade=60}, Student{id=1001, grade=60}]
排序后：[Student{id=1000, grade=60}, Student{id=1001, grade=60}, Student{id=1002, grade=100}]

Comparable和Comparator解析见另一篇文章

Comparable和Comparator解析

One_More_Chance
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【第42天】Arrays.sort 与 Collections.sort 应用 | 整形数组与集合的排序
执梗的博客
02-26 3723
【第42天】Arrays.sort 与 Collections.sort 应用 | 整形数组与集合的排序
详解java Collections.sort的两种用法
08-18
Collections.sort 方法的第二个参数形式是 public static <T> void sort(List<T> list, Comparator<? super T> c)，该方法允许我们通过实现 Comparator 接口的 compare 方法来完成自定义排序。 下面是一个使用...
java arrays.sort排序_Java Arrays.sort和Collections.sort排序实现原理解析
weixin_32103331的博客
02-12 752
1、使用排序2、原理事实上Collections.sort方法底层就是调用的array.sort方法，而且不论是Collections.sort或者是Arrays.sort方法，跟踪下源代码吧，首先我们写个demopublic static void main(String[] args) {List strings = Arrays.asList("6", "1", "3", "1","2");...
Arrays.sort() 自定义排序规则
ASDF的博客
06-27 276
Arrays.sort() 自定义排序规则
java刷题必备排序，Arrays.sort()和Collections.sort()
King_wq_2020的博客
07-19 5097
Arrays.sort()对数组进行排序，Collections.sort()对list集合进行排序。 对于基本数据类型，使用Array.sort() ，默认是升序。 对于基本数据类型的包装类，使用Collections.sort()，默认是升序。 对于元素为实体类（对象），Array.sort()和Collections.sort()都可以自定义排序，只不过一个对数组进行排序，一个对list集合进行排序，但是数组及list集合中元素必须实现comparable接口。 1、基于Arrays.so
Arrays.sort 和 Collections.sort 实现原理和区别？
m0_62986746的博客
05-27 337
然后还有混排（Shuffling）、反转（Reverse）、替换所有的元素（fill）、拷贝（copy）、返回Collections中最小元素（min）、返回Collections中最大元素（max）、返回指定源列表中最后一次出现指定目标列表的起始位置（ lastIndexOfSubList ）、返回指定源列表中第一次出现指定目标列表的起始位置（ IndexOfSubList ）、根据指定的距离循环移动指定列表中的元素（Rotate）;java.util.Collection 是一个集合接口。
Arrays.sort实现降序排序
热门推荐
北冥的博客
06-26 2万+
在调用Arrays.sort()对数组进行排序时，默认是升序排序的，如果想让数组降序排序，有下面两种方法： 1.Collections的reverseOrder import java.util.*; public class Main { public static void main(String[] args) { // 注意这里是Integer，不是int Integer[] arr={9,8,7,6,5,4,3,2,1}; Arrays.s
Arrays.sort和Collections.sort
Pure_Eyes的博客
03-25 832
原先好像在哪里看到Collections.sort与Arrays.sort两者使用了不同的排序方法，结果面试问到却想不起来了，只见面试官写了Timsort 后面加了个“无”字，想来代笔一种算法。现在有空看看源码，发现Collections底层使用的竟然是Arrays的sort方法，瞬间对自己的知识系统标识怀疑了。 Collections.sort 方法如下，可见其直接调用了List接口的方法 @...
【萌姐讲底层原理】Arrays.sort & Collections.sort 底层原理
脚踏实地，仰望星空
12-27 973
where Arrays和Collections 是JDK 中能实现排序的两个工具类，都来自java.util工具包 what Arrays.sort 主要用于数组排序，包括基本类型的数组和对象数组。 Collections.sort 对List等集合类进行排序. 底层实现(jdk1.8版本) Collections.sort 方法调用了list.sort方法 public static <T extends Comparable<? super T>> void sort(
Arrays.sort() 的一些用法
qq_43842093的博客
05-02 1233
Arrays.sort() 的一些用法 介绍 sort(T[] a)：对指定T型数组按数字升序排序。 sort(T[] a,int formIndex, int toIndex)：对指定T型数组的指定范围按数字升序排序。 sort(T[] a, Comparator<? supre T> c): 根据指定比较器产生的顺序对指定对象数组进行排序。 sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根据指
Arrays.sort.Collections.sort 排序出现的java.lang.IllegalArgumentException的异常
琦彦
05-09 2199
1.问题分析(Java 7) 在Java 6中Arrays.sort()和Collections.sort()使用的是MergeSort，而在Java 7中，内部实现换成了TimSort(做了大量优化的归并排序)，其对对象间比较的实现要求更加严格： Comparator的实现必须保证以下几点： 原则1. sgn(compare(x, y)) == -sgn(compare...
Arrays.sort降序排序
qq_44286615的博客
10-12 1759
降序排序
Java Arrays.sort和Collections.sort排序实现原理解析
08-25
Java中的`Arrays.sort()`和`Collections.sort()`是两个常用的排序函数，它们分别用于对数组和集合进行排序。这两个函数在内部实现上有所不同，但都基于高效的排序算法。 首先，`Collections.sort()`方法在处理列表...
JAVA基于Arrays.sort()实现数组升序和降序
08-19
要实现数组的降序排序，我们可以使用 Arrays.sort() 方法并结合 Collections.reverseOrder() 方法，例如： ```java Integer scores[] = {1,2,3,89,4}; Arrays.sort(scores,Collections.reverseOrder()); for ...
Collections集合工具类排序.docx
06-26
首先，`sort(List<T> list)`方法是Collections工具类中最常用的排序方法之一，它根据列表中元素的自然排序（natural ordering）来对列表进行排序。自然排序是指列表中的元素必须实现Comparable接口，该接口定义了一...
java sort排序算法实例完整代码
08-01
这个算法在Java中主要体现在`java.util.Arrays`和`java.util.Collections`两个类中，提供了对数组和集合的排序功能。下面我们将深入探讨`sort`排序算法的工作原理、性能分析以及实际应用示例。 ### 1. `Arrays.sort...
golang 接口
m0_70982551的博客
07-24 951
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 515
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 642
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Collections.sort()和Arrays.sort区别
02-02
Collections.sort()和Arrays.sort()都是用于对数组或集合进行排序的方法，但它们有一些区别。 1. 参数类型不同： - Collections.sort()方法接受一个List类型的参数，用于对List集合进行排序。 - Arrays.sort()...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值