Java Sort 方法的使用（包含Arrays.sort(),Collections.sort()以及Comparable，Comparator的使用 ）

news2024/10/6 10:28:32

目录

Comparable && Comparator的使用：

Comparable:

Comparator:

Arrays.sort()的使用:

升序排序：

 降序排序：

 自定义排序方法：

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

Comparable && Comparator的使用：

Comparable:

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

class Student implements Comparable<Student>{
    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<Student> 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:

Comparable的两种使用方法：

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

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

 //自定义排序：使用匿名内部类，实现Comparator接口，重写compare方法
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getId() - o2.getId();
            }
        });
 //自定义排序2
        list.sort(new Comparator<Student>() {
            @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<Student>{
    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<Student> 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<Student>() {
            @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<Student>() {
            @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数组 <toIndex，左闭右开

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

 降序排序：

实现方法：Collections.reverseOrder()

public static <T> void sort(T[] a,int fromIndex, int toIndex,  Comparator<? super T> 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<Integer>() {
            @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

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

 //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数组 <toIndex
        int[] a = new int[]{2,5,4,1,19,3,2};
        Arrays.sort(a,1,4);
        for(int x : a) System.out.print(x + " ");
    }

    public static void main3(String[] args) {
       /* //1.实现降序排序，基本的数据类型数组是不行的
        int[] a = new int[]{10,293,35,24,64,56};
        Arrays.sort(a,Collections.reverseOrder());
        for(int x : a) System.out.println(x + " ");*/

        //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 + " ");

        System.out.println();
        System.out.println("===================================");
        //3.自定义排序方法,实现java.util.Comparetor 接口中的compare方法
        Integer[] integers2 = new Integer[]{10, 293, 35, 24, 64, 56};

        Arrays.sort(integers2, new Comparator<Integer>() {
            @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 + " ");


    }
}

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

import java.util.Arrays;
import java.util.Comparator;

class Cmp implements Comparator<int[]>{

    @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();
        }
    }
}

运行结果：

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1717171.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【PHP项目实战训练】——laravel框架的实战项目中可以做模板的增删查改功能（1）

【PHP项目实战训练】——laravel框架的实战项目中可以做模板的增删查改功能（1）

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;开发者-曼亿点 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 曼亿点 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a…
阅读更多...
【银河麒麟V10服务器OS-系统根分区扩容】指导教程手册

【银河麒麟V10服务器OS-系统根分区扩容】指导教程手册

【银河麒麟V10服务器OS-系统根分区扩容】指导教程手册 环境信息&#xff1a;VMware虚拟软件16.0 首先查看KylinOS服务器版本&#xff1a;nkvers 备注&#xff1a; (Tercel) 版本是 V10 SP1 版本&#xff0c; (Sword) 版本是 V10 SP2 版本&#xff0c; (Lance) 版本是 V10 …
阅读更多...
开源与闭源 AI 模型：发展路径的比较与前瞻

开源与闭源 AI 模型：发展路径的比较与前瞻

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
super().__init__() 来自于哪个PEP

super().__init__() 来自于哪个PEP

super() 的简化用法&#xff08;即不带参数的 super()&#xff09;是在 Python 3 中引入的。这个改进是由 PEP 3135 规范化的。 PEP 3135: New Super PEP 3135 标题为 “New Super”。它介绍了一种新的方式来调用超类的方法&#xff0c;即不再需要显式地传递当前类和实例&…
阅读更多...
前端Vue小兔鲜儿电商项目实战Day04

前端Vue小兔鲜儿电商项目实战Day04

一、二级分类 - 整体认识和路由配置 1. 配置二级路由 ①准备组件模板 - src/views/SubCategory/index.vue <script setup></script><template><div class"container"><!-- 面包屑 --><div class"bread-container">…
阅读更多...
软件需求规格说明书（Word原件@配套软件全资料）

软件需求规格说明书（Word原件@配套软件全资料）

软件需求规格说明书编写规范编写规范 1.项目背景 2.项目目标 3.系统架构 4.总体流程 5.名称解释 6.功能模块 软件项目相关全套精华资料包获取方式①&#xff1a;点我获取 获取方式②&#xff1a;本文末个人名片直接获取。 软件资料清单列表部分文档清单&#xff1a;工作安排任…
阅读更多...
python操作mongodb底层封装并验证pymongo是否应该关闭连接

python操作mongodb底层封装并验证pymongo是否应该关闭连接

一、pymongo简介 https://pymongo.readthedocs.io/en/stable/github地址&#xff1a;https://github.com/mongodb/mongo-python-driver mymongo安装命令&#xff1a;pip install pymongo4.7.2 mymongo接口文档&#xff1a;PyMongo 4.7.2 Documentation PyMongo发行版包含Py…
阅读更多...
AI绘画Stable Diffusion【实战】一下给我整破防了！！SD制作商业海报——香水海报

AI绘画Stable Diffusion【实战】一下给我整破防了！！SD制作商业海报——香水海报

大家好&#xff0c;我是画画的小强 今天给大家分享关于SD制作商业海报案例——香水海报。内容很干&#xff0c;但很实用&#xff0c;后续也会持续分享一些其他商业海报的制作案例&#xff0c;喜欢的朋友请持续关注 人“狠”话不多&#xff0c;大家请上车&#xff01;&#xff…
阅读更多...
VB.net 进行CAD二次开发（二）

VB.net 进行CAD二次开发（二）

利用参考文献2&#xff0c;添加面板 执行treeControl New UCTreeView()时报一个错误&#xff1a; 用户代码未处理 System.ArgumentException HResult-2147024809 Message控件不支持透明的背景色。 SourceSystem.Windows.Forms StackTrace: 在 System.Windows…
阅读更多...
Java流与链表：探索java.util.stream与LinkedList的交汇点

Java流与链表：探索java.util.stream与LinkedList的交汇点

在现代Java开发中&#xff0c;流&#xff08;Streams&#xff09;和链表&#xff08;LinkedList&#xff09;都是强大且常用的数据处理工具。java.util.stream提供了高效的方式来处理数据流&#xff0c;而LinkedList则是java.util包中的经典集合实现。本文将探索它们的交汇点&a…
阅读更多...
手拉手springboot整合kafka发送消息

手拉手springboot整合kafka发送消息

环境介绍技术栈springbootmybatis-plusmysqlrocketmq软件版本mysql8IDEAIntelliJ IDEA 2022.2.1JDK17Spring Boot3.1.7kafka2.13-3.7.0 创建topic时&#xff0c;若不指定topic的分区(Partition主题分区数)数量使&#xff0c;则默认为1个分区(partition) springboot加入依赖kafk…
阅读更多...
MySQL排序字段无法唯一标识一条数据，导致分页查询结果出现重复或遗漏问题

MySQL排序字段无法唯一标识一条数据，导致分页查询结果出现重复或遗漏问题

问题描述 MySQL排序字段无法唯一标识一条数据&#xff0c;且排序字段可能有多个&#xff0c;多个排序字段无法唯一标识一条数据&#xff0c;即排序字段标识的相同数据过多&#xff0c;可能导致分页查询出现重复或遗漏的情况。 具体说明&#xff1a;      如果在排序条件中…
阅读更多...
Stable Diffusion AI绘画：从创意词汇到艺术图画的魔法之旅

Stable Diffusion AI绘画：从创意词汇到艺术图画的魔法之旅

文章目录 一、Stable Diffusion的工作原理二、从提示词到模型出图的过程三、Stable Diffusion在艺术创作中的应用《Stable Diffusion AI绘画从提示词到模型出图》内容简介作者简介楚天 目录前言/序言本书特色特别提示 获取方式 在科技的飞速发展中&#xff0c;Stable Diffusion…
阅读更多...
江协科技STM32学习-1 购买24Mhz采样逻辑分析仪

江协科技STM32学习-1 购买24Mhz采样逻辑分析仪

前言&#xff1a; 本文是根据哔哩哔哩网站上“江协科技STM32”视频的学习笔记&#xff0c;在这里会记录下江协科技STM32开发板的配套视频教程所作的实验和学习笔记内容。本文大量引用了江协科技STM32教学视频和链接中的内容。 引用&#xff1a; STM32入门教程-2023版 细致讲…
阅读更多...
机器人系统ros2-开发学习实践16-RViz 用户指南

机器人系统ros2-开发学习实践16-RViz 用户指南

RViz 是 ROS&#xff08;Robot Operating System&#xff09;中的一个强大的 3D 可视化工具&#xff0c;用于可视化机器人模型、传感器数据、路径规划等。以下是RViz用户指南&#xff0c;帮助你了解如何使用RViz来进行机器人开发和调试。 启动可视化工具 ros2 run rviz2 rviz2…
阅读更多...
【React篇】组件错误边界处理（组件错误引起的页面白屏）

【React篇】组件错误边界处理（组件错误引起的页面白屏）

我们知道在生产环境react错误会导致整个页面崩溃&#xff0c;显示为空白页面。 比如下图的错误&#xff0c;导致了左侧页面直接白屏&#xff1a; 由于某一个组件报错导致整个页面崩溃是很严重的问题&#xff0c;那么我们应该如何去降低代码报错带来的影响呢&#xff1f; 我们…
阅读更多...
Rockchip芯片 写SN,IMEI,Mac等 写attenstation key 写Remote Key Provisioning

Rockchip芯片 写SN,IMEI,Mac等 写attenstation key 写Remote Key Provisioning

下载AP 写SN等 关机下 按住“音量” 插入USB线 进入loader 方式&#xff0c;在该模式下面写号&#xff0c;设备必须是已经有烧写过固件。 输入sn&#xff0c;点写入&#xff0c;成功。 点读取&#xff0c;成功。 两种设备模式&#xff1a;maskrom 和 loader 模式 maskrom 进…
阅读更多...
灶新趋势，跌下神坛的电磁炉，为何被人嫌弃

灶新趋势，跌下神坛的电磁炉，为何被人嫌弃

在厨电市场的广阔天地中&#xff0c;电燃灶与电磁炉作为两种截然不同的烹饪工具&#xff0c;其间的竞争与演变始终牵动着消费者的心弦。近年来&#xff0c;电燃灶以其独特的优势崭露头角&#xff0c;而电磁炉则似乎从昔日的辉煌中跌下神坛&#xff0c;遭到越来越多人的嫌弃。这…
阅读更多...
[排序算法]插入排序+希尔排序全梳理！

[排序算法]插入排序+希尔排序全梳理！

目录 1.排序是什么&#xff1f;1.1排序的概念1.2排序运用1.3常见的排序算法 2.插入排序分类3.直接插入排序基本思想具体步骤&#xff1a;动图演示代码实现直接插入排序的特性总结&#xff1a; 4. 希尔排序基本思想具体步骤动图演示代码实现希尔排序的特性总结&#xff1a; 5.总…
阅读更多...
一种改进的经验小波变换方法（Python环境）

一种改进的经验小波变换方法（Python环境）

经验小波变换EWT是Gilles基于小波分析理论提出的一种新的自适应信号分解方法&#xff0c;该方法主要分为三个步骤&#xff1a;1.根据傅里叶谱的特性自适应划分频谱&#xff0c;获得一组边界&#xff1b;2.根据边界序列和Meyer小波构造滤波器组&#xff1b;3.滤波重构&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023