Java Arrays自定义排序的五种写法

最新推荐文章于 2024-03-16 19:42:43 发布
最新推荐文章于 2024-03-16 19:42:43 发布
阅读量1.2k 收藏 3
点赞数 2
分类专栏： Java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/For_learning/article/details/130660145
版权

Java Arrays自定义排序的几种写法

1. 类对象实现Comparable接口

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // 类实现Comparable接口
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

class A implements Comparable<A>{
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }
  	
  	@Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }

    @Override
    public int compareTo(@NotNull A o) {
        return grade - o.grade;
    }
}

2. 创建实现Comparator接口的类/匿名内部类

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // 创建实现Comparator的类/匿名类
        Arrays.sort(arr, new Comparator<A>() {
            @Override
            public int compare(A o1, A o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        System.out.println(Arrays.toString(arr));

		Arrays.sort(arr, new Tools());
		System.out.println(Arrays.toString(arr));
    }
}

class Tools implements Comparator<A> {
    @Override
    public int compare(A o1, A o2) {
        return o1.getGrade() - o2.getGrade();
    }
}

class A {
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
}

3. 基于Comparator构建Lambda表达式

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // 基于Comparator构建Lambda表达式
        Comparator<A> comp = (A o1, A o2) -> {
            return o1.getGrade() - o2.getGrade();
        };
        Arrays.sort(arr, comp);
        System.out.println(Arrays.toString(arr));
    }
}

class A {
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
}

4. Comparator类的comparing方法，可以搭配lambda表达式

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // Comparator类的comparing方法，可以搭配lambda表达式
        Arrays.sort(arr, Comparator.comparing(A::getGrade).thenComparing(A::getName));
        System.out.println(Arrays.toString(arr));

        Arrays.sort(arr, Comparator.comparing(A::getName,
                ((o1, o2) -> {return o1.length() - o2.length();})
        ));
        System.out.println(Arrays.toString(arr));
    }
}

class A {
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
}

5. // Comparator类的comparingInt方法，comparing方法的变体

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // Comparator类的comparingInt方法，可以搭配lambda表达式，comparing的变体
        Arrays.sort(arr, Comparator.comparingInt(o -> o.getName().length()));
        System.out.println(Arrays.toString(arr));
    }
}

class A {
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
}

6. 完整示例代码

package com.javaLearn.customSort_;

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

public class Sort01 {
    public static void main(String[] args) {
        A[] arr = new A[4];
        arr[0] = new A("aaa", 10);
        arr[1] = new A("cc", 8);
        arr[2] = new A("dddd", 11);
        arr[3] = new A("bb", 3);

        // 类实现Comparable接口
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 创建实现Comparator的类/匿名类
        Arrays.sort(arr, new Comparator<A>() {
            @Override
            public int compare(A o1, A o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        System.out.println(Arrays.toString(arr));

        Arrays.sort(arr, new Tools());
        System.out.println(Arrays.toString(arr));

        // 基于Comparator构建Lambda表达式
        Comparator<A> comp = (A o1, A o2) -> {
            return o1.getGrade() - o2.getGrade();
        };
        Arrays.sort(arr, comp);
        System.out.println(Arrays.toString(arr));

        // Comparator类的comparing方法，可以搭配lambda表达式
        Arrays.sort(arr, Comparator.comparing(A::getGrade).thenComparing(A::getName));
        System.out.println(Arrays.toString(arr));

        Arrays.sort(arr, Comparator.comparing(A::getName,
                ((o1, o2) -> {return o1.length() - o2.length();})
        ));
		System.out.println(Arrays.toString(arr));

        // Comparator类的comparingInt方法，可以搭配lambda表达式，comparing的变体
        Arrays.sort(arr, Comparator.comparingInt(o -> o.getName().length()));
        System.out.println(Arrays.toString(arr));

    }
}

class A implements Comparable<A>{
    private String name;

    private int grade;

    public A(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }

    @Override
    public int compareTo(@NotNull A o) {
        return grade - o.grade;
    }
}

class Tools implements Comparator<A> {
    @Override
    public int compare(A o1, A o2) {
        return o1.getGrade() - o2.getGrade();
    }
}
今生有幸.~
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java的arrays数组排序示例分享
09-04
排序算法，基本的高级语言都有一些提供。C语言有qsort()函数，C++有sort()函数，java语言有Arrays类(不是Array)。用这些排序时，都可以写自己的排序规则
java竞赛中各种自定义排序模板
12-22
如果要按照某一个属性来对这个对象数组进行升序或降序排序，那么就需要用Arrays.sort()，但是这个创建的类一定要继承Comparable这个接口并重写compareTo方法。代码如下： package 排序; import java.util.Arrays; ...
java Arrays.sort()通过自己设定来排序
m0_55847943的博客
11-12 5416
虽然这种情况很普遍，但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来，任何违背这个条件的Comparator 都应该清楚地指出这一事实。推荐的语言是“注意：此 Comparator 强行进行与 equals 不一致的排序。”参数： o1 - 要比较的第一个对象。o2 - 要比较的第二个对象。返回：根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
Arrays.sort()方法对自定义对象的排序
最新发布
qq_59153009的博客
03-16 635
Arrays.sort()方法对自定义对象的排序; 1.Student类实现java.lang包下的Comparable接口，并重写其中的compareTo方法 2.用一个类继承java.util包下面的Comparator接口实现里面的compare方法,然后再调用sort方法时new 一个该类的匿名对象作为第二个参数。
Java——Arrays.sort自定义排序两种方式
生命不息，奋斗不止
10-25 3439
Comparable接口 是你要进行排序的 数据结构或者说对象 所对应的类需要实现的接口，缺点是只能按你实现的这一种方式排序： public class UserInfo implements Comparable<UserInfo> { private int id; private String userName; private String phone; pri...
Java中关于Arrays.sort方法的两种自定义排序方式
AnLikuangmo的博客
10-31 2549
一、Comparable接口 Comparable是一个排序接口 此接口给实现类提供了一个排序的方法,此接口有且只有一个方法(接口中没有声明public是因为接口方法默认为public,但调用该方法时必须声明public) int compareTo(T o); 实例:通过id进行排序 public class UserInfo implements Comparable<UserInfo...
Java中Arrays.sort()的三种常用用法（自定义排序规则）
热门推荐
ssjdoudou的博客
08-08 7万+
Arrays.sort(int[] a) 这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。 举例如下： import java.util.Arrays; public class Main { public static void main(String[] args) { int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a); for(int i = 0
java自定义排序
qq_45733304的博客
04-23 6838
java中sort的自定义排序一、Arrays.sort(nums)的一般用法二、最大数（力扣179）三、合并区间（力扣59） 一、Arrays.sort(nums)的一般用法 整个数组按照升序排序 若需要降序排序，将数组转置即可 int[] testNums = {1,3,6,5,4,1,2,8}; Arrays.sort(testNums); System.out.println(Arrays.toString(testNums)); //输出：[1, 1, 2, 3, 4, 5, 6, 8]
java中Arrays.sort()方法自定义排序规则的注意事项
TLBWYJ的博客
05-09 262
这里需要注意要将nums数组转成String类型的数组，因为源码中Arrays.sort()调用的comparator接口中函数的两个参数为T（泛型），而nums数组的类型为int，这里不会自动转化为Integer类型，所以会报错。或者也可以直接将nums数组转化为Integer数组，但需要修改重写的方法。
Java基础——Arrays类的排序方法
weixin_61275790的博客
04-06 1328
public static void sort(类型[] a, Comparator
Java Arrays.sort()自定义排序方法
qq_42520962的博客
10-30 6245
Java Arrays.sort可以对很多数据类型进行排序，但是当需要对一个比较特殊的数组进行排序的时候，比如一个二维数组，我们要以每组的第一个数大小来排序，则需要我们自己定义一个比较方法。 先看看源码 public static <T> void sort(T[] a, Comparator<? super T> c) { if (c == null) { sort(a); } else {
Java Arrays.sort和Collections.sort排序实现原理解析
08-25
主要介绍了Java Arrays.sort和Collections.sort排序实现原理解析，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java Arrays工具类用法详解
08-26
主要介绍了Java Arrays工具类用法,结合实例形式分析了java Arrays工具类针对数组元素修改、复制、排序等操作使用技巧与相关注意事项,需要的朋友可以参考下
Java数组高级算法与Arrays类常见操作小结【排序、查找】
08-26
主要介绍了Java数组高级算法与Arrays类常见操作,结合实例形式总结分析了Java数组常见的排序算法、查找算法相关原理、实现与使用技巧,需要的朋友可以参考下
Java八大基本排序和查找
weixin_43834120的博客
04-09 268
排序： 插入排序：直接插入排序、希尔排序 交换排序：冒泡排序、快速排序 选择排序：简单选择排序、堆排序 归并排序 基数排序 /*** ** 插入排序 ** 时间复杂度：O(n2) 空间复杂度：O(1) ** 稳定性：稳定 ** 后移数据，往前面插 * 外层循环记录下标为1及后面的数据到temp中,内层循环将temp的数据往前面移放到合适的位置 */ public class Sor...
java 中 自定义对象数组排序 Arrays.sort()方法 以及 Compareable接口和Compartor接口对比分析
大帅 的CSDN技术尬blog!
09-15 2万+
java 中 自定义对象数组排序 Arrays.sort()方法 以及 Compareable接口和Compartor接口对比分析 对自定义对象数组排序，需要引入“比较器”，的概念。 Compareable和Compartor接口就是比较器抽象接口，通过实现类，重写接口方法来进行对象比较。 Arrays.sort()有2个重载方法，见下 sort(Objetc[] a) ...
Java Arrays类排序方法
小钟不想敲代码
01-17 1292
Arrays类排序方法
Java 实现对Arrays类 自定义 排序sort的2种方法
蓝莲花
06-26 1788
一、实现Comparable接口(用于类之间的排序)：  假设有Employee类，有name和salary字段， 需要实现Comparable<T>接口： public class Employee implements Comparable<Employee> { private String name; private ...
java实现自定义排序
09-12
在Java中实现自定义排序可以使用Comparator接口。Comparator接口有一个compare()方法，通过实现这个方法可以定义自己的排序规则。在使用Arrays.sort()方法或List的sort()方法时，可以传入Comparator对象来实现自定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值