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

目录

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

运行结果：

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

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【C++修行之道】类和对象（二）类的6个默认成员函数、构造函数、析构函数

【C++修行之道】类和对象（二）类的6个默认成员函数、构造函数、析构函数

目录 一、类的6个默认成员函数 二、构造函数 2.1 概念 2.2 特性 2.2.5 自动生成默认构造函数 不进行显示定义的隐患&#xff1a; 2.2.6 自动生成的构造函数意义何在&#xff1f; 两个栈实现一个队列 2.2.7 无参的构造函数和全缺省的构造函数都称为默认构造函数&#x…
阅读更多...
ELK 使用 metricbeat监控数据

ELK 使用 metricbeat监控数据

IP功能版本192.168.140.153elk-18.13.4192.168.140.153metricbeat8.13.4192.168.140.156elk-28.13.4192.168.140.156metricbeat8.13.4192.168.140.159logstash8.13.4192.168.140.159kibana8.13.4 一、安装ELK 参考文档&#xff1a; https://download.csdn.net/download/weix…
阅读更多...
【免费Web系列】JavaWeb实战项目案例四

【免费Web系列】JavaWeb实战项目案例四

这是Web第一天的课程大家可以传送过去学习 http://t.csdnimg.cn/K547r 多表操作&员工列表查询 1. 多表关系 关于单表的操作(单表的设计、单表的增删改查)我们就已经学习完了。接下来我们就要来学习多表的操作&#xff0c;首先来学习多表的设计。 项目开发中&#xff0…
阅读更多...
2023年全球DDoS攻击现状与趋势分析

2023年全球DDoS攻击现状与趋势分析

天翼安全科技有限公司副总工程师、运营保障部总经理陈林表示&#xff0c;2023年扫段攻击频次快速增长&#xff0c;成为网络基础设施面临的最大威胁。为躲避防御&#xff0c;低速扫段攻击成为主流达到攻击总数的73.19%&#xff1b;43.26%的C段攻击持续时间小于5分钟&#xff0c;…
阅读更多...
面试题vue+uniapp（个人理解-面试口头答述）未编辑完整....

面试题vue+uniapp（个人理解-面试口头答述）未编辑完整....

1.vue2和vue3的区别&#xff08;vue3与vue2的区别&#xff08;你不知道细节全在这&#xff09;_vue2和vue3区别-CSDN博客&#xff09;参考 Vue3 在组合式&#xff08;Composition &#xff09;API&#xff0c;中使用生命周期钩子时需要先引入&#xff0c;而 Vue2 在选项API&am…
阅读更多...
车载以太网的未来：OPEN Alliance下17个技术委员会的最新进展与行业影响（下）

车载以太网的未来：OPEN Alliance下17个技术委员会的最新进展与行业影响（下）

从上篇介绍来看&#xff0c;TC1-TC8大多数处于暂停或完成状态。而TC9-TC17在2023年都有不同程度的进展&#xff0c;让我们继续探索藏在其中的车载以太网的发展和挑战。 TC9 Automotive Ethernet Channel & Components&#xff08;in progress&#xff09; TC9的目标是为通…
阅读更多...
基础9 探索图形化编程的奥秘：从物联网到工业自动化

基础9 探索图形化编程的奥秘：从物联网到工业自动化

办公室内&#xff0c;明媚的阳光透过窗户洒落&#xff0c;为每张办公桌披上了一层金色的光辉。同事们各自忙碌着&#xff0c;键盘敲击声、文件翻页声和低声讨论交织在一起&#xff0c;营造出一种忙碌而有序的氛围。空气中氤氲着淡淡的咖啡香气和纸张的清新味道&#xff0c;令人…
阅读更多...
【PHP项目实战训练】——laravel框架的实战项目中可以做模板的增删查改功能（2）

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

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;开发者-曼亿点 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 曼亿点 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a…
阅读更多...
linux centos nfs挂载两台服务器挂载统一磁盘目录权限问题

linux centos nfs挂载两台服务器挂载统一磁盘目录权限问题

查看用户id id 用户名另一台为 修改uid和gid为相同id&#xff0c;添加附加组 usermod -u500 -Gwheel epms groupmod -g500 epms
阅读更多...
SQL Server定期收缩日志文件详细步骤——基于SQL Server 2012

SQL Server定期收缩日志文件详细步骤——基于SQL Server 2012

SQL Server定期收缩日志文件详细步骤 一、环境配置1、查看数据库的属性2、文件设置3、备份模式4、查看收缩配置5、查看收缩选项 二、编写作业计划1、选择新建作业2、常规配置3、步骤4、输入内容5、脚本详解6、新建计划7、输入名称、选择执行时间8、查看测试9、查看测试结果 一、…
阅读更多...
Mistral发布首个代码生成人工智能模型Codestral 但不可用于商业活动

Mistral发布首个代码生成人工智能模型Codestral 但不可用于商业活动

由微软支持、估值高达 60 亿美元的法国人工智能初创公司 Mistral发布了首个用于编码的生成式人工智能模型&#xff0c;名为 Codestral。Codestral 与其他代码生成模型一样&#xff0c;旨在帮助开发人员编写代码并与之交互。 Mistral 在一篇博文中解释说&#xff0c;它接受过 80…
阅读更多...
想学习中医的看过来

想学习中医的看过来

近年来&#xff0c;随着短视频的兴起&#xff0c;中国传统文化&#xff0c;在各大平台成为热搜&#xff0c;且有愈演愈烈之势。证明&#xff0c;国人开始重视起自己的文化&#xff0c;这是一个好的现象。中医学&#xff0c;作为传统文化中不可或缺的一员&#xff0c;也受到了广…
阅读更多...
分布式架构设计之Base理论深度剖析：从理论到实践的完美融合

分布式架构设计之Base理论深度剖析：从理论到实践的完美融合

文章目录 引言一、Base理论概述1.1. 基本可用&#xff08;Basically Available&#xff09;1.2. 软状态&#xff08;Soft State&#xff09;1.3. 最终一致性&#xff08;Eventually Consistent&#xff09; 二、Base理论在分布式架构设计中的应用2.1. 分布式数据库设计2.2. 分布…
阅读更多...
C语言分支和循环（2）

C语言分支和循环（2）

我的相关博客&#xff1a; C语言的分支与循环&#xff08;1&#xff09; 1.switch语句 除了 if 语句外&#xff0c;C语⾔还提供了 switch 语句来实现分⽀结构。 switch 语句是⼀种特殊形式的 的 if...else 结构&#xff0c;⽤于判断条件有多个结果的情况。它把多重 else if…
阅读更多...
用Unityhub安装unity2018.3.0和vuforia

用Unityhub安装unity2018.3.0和vuforia

打开下载网址 https://unity.cn/releases/full/2018 选择2018.3.x 找到2018.3.0后&#xff0c;点击从UnityHub下载 然后unityhub会弹出安装界面 只勾选这两个&#xff0c;其余的全部取消勾选&#xff0c;默认勾选上的也取消掉&#xff0c;然后点击安装
阅读更多...
【观察】研华科技：奏响数智化转型“交响乐”，将新质生产力融入千行百业...

【观察】研华科技：奏响数智化转型“交响乐”，将新质生产力融入千行百业...

加快发展新质生产力&#xff0c;已成为当前的主旋律。特别是近年来&#xff0c;以人工智能、大模型、大数据、云计算为代表的数字技术的一系列革命性突破&#xff0c;引发了传统生产要素以及以数据为代表的新生产要素的融合与创新配置&#xff0c;不仅成为推动新质生产力发展的…
阅读更多...
开发语言Java+前端框架Vue+后端框架SpringBoot开发的ADR药物不良反应监测系统源码 系统有哪些优势？

开发语言Java+前端框架Vue+后端框架SpringBoot开发的ADR药物不良反应监测系统源码 系统有哪些优势？

开发语言Java前端框架Vue后端框架SpringBoot开发的ADR药物不良反应监测系统源码 系统有哪些优势&#xff1f; ADR药物不良反应监测系统具有多个显著的优势&#xff0c;这些优势主要体现在以下几个方面&#xff1a; 一、提高监测效率与准确性&#xff1a; 通过自动化的数据收集…
阅读更多...
Flask初体验

Flask初体验

这里有一份展示Flask与Python的协同代码&#xff0c;Flask的web页面展示了系统的一个暴露的公共tcp port连接的所有用户ip:port列表。 做完才发现没有什么用处&#xff0c;我的本意是做一个reverse的ssh或者telnet终端。看点有几个&#xff1a; 我原本是打算用multiprocessin…
阅读更多...
音视频开发13 FFmpeg 音频 相关格式分析 -- AAC ADTS格式分析

音视频开发13 FFmpeg 音频 相关格式分析 -- AAC ADTS格式分析

这一节&#xff0c;我们学习常用的音频的格式 AAC&#xff0c;重点是掌握 AAC的传输格式 ADTS 头部的信息&#xff0c;目的是 &#xff1a; 当音频数据有问题的时候&#xff0c;如果是AAC的编码&#xff0c;在分析 头部信息的时候能够根据头部信息 判断问题是否出现在 头部。 A…
阅读更多...
C++第二十二弹---vector深度剖析及模拟实现(下)

C++第二十二弹---vector深度剖析及模拟实现(下)

✨个人主页&#xff1a; 熬夜学编程的小林 &#x1f497;系列专栏&#xff1a; 【C语言详解】 【数据结构详解】【C详解】 目录 1、容量操作 2、内容修改操作 3、打印函数 4、迭代器失效 4.1、什么是迭代器失效 4.2、哪些操作会引起迭代器失效 总结 1、容量操作 size()…
阅读更多...
最新文章

Copyright @ 2022~2023