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

已于 2024-06-09 23:38:01 修改
阅读量2.1k 收藏 80
点赞数 88
分类专栏： javaSE 文章标签： java 开发语言
于 2024-05-30 20:22:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79862386/article/details/139325796
版权

目录

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:

Comparator的两种使用方法：

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

运行结果：

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

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

IYF.星辰
关注
  • 88
    点赞
  • 踩
  • 80
    收藏
    觉得还不错? 一键收藏
  • 81
    评论
专栏目录
java list多字段排序_java中list通过多条件排序
weixin_31421613的博客
02-12 1937
实现的效果类似于这样,首先通过一级类别id排序，其次是二级类别，最后是二级类别中的各项合计排序； 方法一/*** 单品容器排序** @param productSellStatList* @return*/private void getSortList(List productSellStatList) {Collections.sort(productSellStatList, new Com...
【Java基础·Comparator多字段排序】
biaogexf
06-07 2790
【Java基础·Comparator多字段排序】 需求 对指定List按照 身份证号、姓名、入学时间倒序排列 版本1 package com.biaogexf.tools; import lombok.Data; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class MultiFieldSortByCompa
详解java Collections.sort的两种用法
08-18
主要介绍了详解java Collections.sort的两种用法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java list按照元素对象的指定多个字段属性进行排序
Enable1234___的专栏
11-18 1万+
java list按照元素对象的多个字段属性进行排序
Java Collections.sort 多字段排序的现代实现
小湘西的博客
04-01 335
这种方式的代码更加简洁和现代，利用了Java 8引入的lambda表达式和方法引用，使得代码更加易于阅读和维护。此外，它也避免了创建匿名内部类的需要。方法添加了一个基于用户年龄的排序规则。这样，我们就创建了一个排序规则链，它首先按照姓名排序，如果姓名相同，则按照年龄排序。方法来创建一个基于用户姓名的Comparator，然后通过。在这个示例中，我们使用了。
Arrays.sort()和Collections.sort()的用法及比较
michiko98的博客
03-15 2528
Arrays.sort Arrays.sort 针对任意对象，排序的类型就为传入的对象类 如：Arrays.sort(a)//这里a为数组，可以是 int/String /类 数组，排序类型依次为int ,String ，类 Collections.sort Collections.sort 针对集合（List）,排序类型为List对应的类型 如：Collections.sort (l)//这里...
java arrays.sort排序_【转】Java中Collections.sort()和Arrays.sort()所采用的排序算法
weixin_32153867的博客
02-16 138
Java中如果需要对一个collections排序，需要继承于Comparable或者comparator接口，那么使用的排序算法是什么呢，一般情况下，排序算法包括：插入排序、快速排序、合并排序、冒泡排序等，java的Collections.sort算法调用的是合并排序，它是稳定排序，当数据接近有序的时候，效率更高，collections中的数据在排序前需要输入到array中，接着调用Arrays...
Collections的sort排序多个字段
menghuannvxia的专栏
12-28 1098
Collections.sort(testList, new Comparator<Test>() { @Override public int compare(Test o1, Test o2) { if (o1.getType().compareTo(o2.getType()) == 0) { return o1.getName().compareTo(o2.getName()); } else { return o2.getT.
Collections.sort 多个字段排序
面朝大海，春暖花开
04-18 168
按年龄升序，工资升序。
java List多字段排序
gongwq的博客
09-04 4481
今天遇到的一个问题List集合的多字段排序问题。对于一个对象，它有多个属性值，可能会根据不同的属性值对集合有个排序。 对集合的排序，主要是用到的是Collections.sort（List, Comparator）方法，或者是List.sort(Comparator c)两个方法，里面实现了compare()方法。 int compare(T o1, T o2) 比较用来
java 按list对象多个字段排序
热门推荐
yinxianluo的专栏
02-12 3万+
Java List中的数据如何根据对象的某一个或多个字段排序引出Comparable和comparator的使用       第一节  对于引入题目的探讨 首先把引入题目表述的清楚一些，在一个List中存储的是一些对象实例，而对象实例包含多个属性字段，我们要根据对象的某个或者多个属性来对List进行排序。 假设List中存储的都是Student类的实例，Student类
Java 中Comparable和Comparator区别比较
09-05
如果你有一个实现了`Comparable`接口的类的对象列表，比如`List<MyClass>`，你可以直接使用`Collections.sort()`或`Arrays.sort()`对其进行排序。同样，这样的对象也可以作为`TreeMap`的键或`TreeSet`的元素，因为...
详解Java中Comparable和Comparator接口的区别
08-29
* 一个类实现了Comparable接口，就意味着“该类本身支持排序”，它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。 * (02) "Comparator" * 它是一个比较器接口，包括两个函数：compare() 和 equals...
java的Comparator和Comparable.docx
10-26
当一个类实现了 Comparable 接口，那么该类的对象就可以直接调用 Collections.sort 或 Arrays.sort 进行排序。 例如，User 类原本没有排序功能，但当我们让它实现 Comparable<User> 接口后，就可以为 User 对象添加...
Java中实现Comparable和Comparator对象比较
09-02
在实际使用时，我们可以将Comparator实例传递给Collections.sort()或Arrays.sort()方法，实现自定义排序： ```java LinkedList<Person> al = new LinkedList(); // 添加Person对象... Collections.sort(al, new ...
java sort 排序多个_在Java中使用Collections.sort 依据多个字段排序
weixin_42363662的博客
02-28 2941
一、如何使用Collections工具类进行排序使用Collections工具类进行排序主要有两种方式：1.对象实现Comparable接口，重写compareTo方法/*** @author Hanstrovsky*/@Data@AllArgsConstructorpublic class Student implements Comparable {String name;int age;@O...
Java中Colletcions.sort方法详解以及Comparable和Comparator两个接口的区别
qq_41857397的博客
11-02 2269
java Collections.sort的用法以及Comparable和Comparator两个接口的区别
数据结构与算法-差分数组及应用
最新发布
qq_36115196的博客
06-20 975
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
collections.sort和arrays.sort
03-16
collections.sort和arrays.sort都是用于对数组或集合进行排序的方法，但是它们有一些不同之处。 collections.sort是Java集合框架中的方法，可以对List集合进行排序。它需要一个实现了Comparable接口的对象列表作为参数，然后将列表中的元素按照它们的自然顺序排序。如果列表中的元素没有实现Comparable接口，则需要提供一个Comparator对象来指定排序规则。 相比之下，arrays.sort是Java数组类的静态方法，可以对数组进行排序。它也需要一个实现了Comparable接口的对象数组作为参数，然后将数组中的元素按照它们的自然顺序排序。如果数组中的元素没有实现Comparable接口，则需要提供一个Comparator对象来指定排序规则。 此外，arrays.sort可以对基本类型的数组进行排序，而collections.sort只能对对象类型的集合进行排序。但是，可以通过将基本类型的数组转换为对象类型的集合来绕过这个限制。 总的来说，collections.sort和arrays.sort都是非常有用的排序工具，可以根据需要选择使用哪种方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 81
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值