Java自定义排序用法

于 2024-02-02 20:30:15 发布
阅读量1k 收藏 9
点赞数 31
分类专栏： javaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48935611/article/details/135991614
版权

Java自定义排序用法

在Java中，我们可以使用自定义排序来对对象或数组进行排序。这可以通过实现 Comparator 接口或使用 Comparable 接口来实现。下面是两种方法的示例：

1.使用 Comparator 接口（常用）

当我们需要以不同的方式比较两个对象时，可以使用 Comparator 接口来实现自定义排序。这个接口有一个方法 compare(T o1, T o2)，它接收两个泛型参数 T，并返回一个 int 类型的值。这个返回值指示了两个对象的大小关系，具体含义如下：

  • 如果返回值为负数，则表示 o1 小于 o2——不交换
  • 如果返回值为零，则表示 o1 等于 o2——不交换
  • 如果返回值为正数，则表示 o1 大于 o2——交换

当使用排序算法（如 Arrays.sort() 或 Collections.sort()）时，它们会根据 Comparator 的比较结果来决定是否交换两个元素的位置。如果返回值为负数或零，表示元素顺序已经符合要求，不需要交换；如果返回值为正数，表示元素顺序需要交换，算法会进行交换操作。

例如，在以下代码中：

Arrays.sort(array, new Comparator<Integer>() {
    @Override
    public int compare(Integer num1, Integer num2) {
        return num1 - num2;  // 升序排序
    }
});

如果 compare() 方法返回负数，则表示 num1 小于 num2，这时不会交换它们的位置。如果返回正数，则表示 num1 大于 num2，算法会交换它们的位置。

需要注意的是，如果直接返回 num1 - num2，可能会导致整数溢出问题。为了避免这个问题，可以使用 Integer.compare(num1, num2) 方法，它会考虑到溢出情况，返回正确的比较结果。

Integer.compare(num1, num2) 方法是一个静态方法，用于比较两个整数的大小。它返回一个 int 值。
在排序算法中，当使用 Integer.compare(num1, num2) 方法作为比较器时，根据返回值的不同，交换的情况如下：

  • 如果返回值为负数，则表示 num1 小于 num2，此时不进行交换。
  • 如果返回值为零，则表示 num1 等于 num2，也不进行交换。
  • 如果返回值为正数，则表示 num1 大于 num2，此时会进行交换。

需要注意的是，Integer.compare(num1, num2) 方法会考虑到整数溢出的情况，因此可以安全地使用该方法进行比较。

Arrays.sort(array, new Comparator<Integer>() {
    @Override
    public int compare(Integer num1, Integer num2) {
        return Integer.compare(num1, num2);  // 升序排序
    }
});

下面是三个不同的例子，用来说明如何使用 Comparator 接口进行自定义排序：

（1） 根据字符串长度排序

在这个例子中，我们将按照字符串长度对字符串数组进行排序。短字符串排在前面，长字符串排在后面。

import java.util.Arrays; // 导入Arrays类，提供了数组相关的工具方法
import java.util.Comparator; // 导入Comparator接口，该接口定义了比较两个对象的方法。

public class Main {
    public static void main(String[] args) {
        String[] strings = {"aaa", "bb", "c", "dddd"}; // 定义一个字符串数组

        // 使用Arrays.sort方法对字符串数组进行排序，第二个参数是一个Comparator接口实现类的实例，
        // 匿名内部类方式实现了Comparator接口，定义比较方法compare，比较规则为比较两个字符串长度大小。
        Arrays.sort(strings, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });

        System.out.println(Arrays.toString(strings)); // 打印排序后的字符串数组
    }
}

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

public class Main {
    public static void main(String[] args) {
        String[] strings = {"aaa", "bb", "c", "dddd"};

        // 使用Lambda表达式替换匿名内部类实现Comparator接口
        Arrays.sort(strings, (s1, s2) -> s1.length() - s2.length());

        System.out.println(Arrays.toString(strings));
    }
}

在这个例子中，我们使用了匿名内部类来实现 Comparator 接口，并在其中重写了 compare() 方法。
该方法根据字符串的长度进行排序。最后，我们使用 Arrays.sort() 方法对字符串数组进行排序，并输出排序后的结果。

（2） 根据字符串长度和字典序排序

在这个例子中，我们将按照字符串长度和字典序对字符串数组进行排序。短字符串排在前面，长字符串排在后面，如果长度相等，则按照字典序排序。

import java.util.Arrays; // 导入Arrays类，提供了数组相关的工具方法
import java.util.Comparator; // 导入Comparator接口，该接口定义了比较两个对象的方法。

public class Main {
    public static void main(String[] args) {
        String[] strings = {"aaa", "cc", "bb", "a"}; // 定义一个字符串数组

        // 使用Arrays.sort方法对字符串数组进行排序，第二个参数是一个Comparator接口实现类的实例，
        // 匿名内部类方式实现了Comparator接口，定义比较方法compare，比较规则为先比较字符串长度，长度相等时再比较字典序。
        Arrays.sort(strings, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                int lenComp = s1.length() - s2.length(); // 比较字符串长度
                if (lenComp != 0) { // 如果长度不等，则返回长度差值
                    return lenComp;
                } else { // 如果长度相等，则返回字典序比较结果
                    return s1.compareTo(s2);
                }
            }
        });

        System.out.println(Arrays.toString(strings)); // 打印排序后的字符串数组
    }
}
============================================================================
import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        String[] strings = { "aaa", "cc", "bb", "a" };

        // 使用Lambda表达式对字符串数组进行排序
        Arrays.sort(strings, (s1, s2) -> {
            int lenComp = s1.length() - s2.length();
            if (lenComp != 0) {
                return lenComp;
            } else {
                return s1.compareTo(s2);
            }
        });

        System.out.println(Arrays.toString(strings));
    }
}

在这个例子中，我们同样使用了匿名内部类来实现 Comparator 接口。首先，我们按照字符串的长度进行比较，如果长度相等，则再按照字典序进行比较。最后，我们使用 Arrays.sort() 方法对字符串数组进行排序，并输出排序后的结果。

Tips：

compareTo 是Java中String类的一个方法，用于比较两个字符串的大小关系。

s1.compareTo(s2) 的作用是比较字符串s1和s2的字典序（按照字符的Unicode码值进行比较）。

例如，如果s1是"aaa"，s2是"aaab"，那么s1.compareTo(s2)将返回一个负数，表示s1在s2之前。

需要注意的是，compareTo方法要求两个字符串必须是非空的，否则可能会抛出空指针异常。因此，在实际使用时，需要确保s1和s2都不为null。

（3）根据对象属性排序

在这个例子中，我们将按照人物的年龄对人物数组进行排序。年龄小的人排在前面，年龄大的人排在后面。

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

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = {
                new Person("卡卡罗特", 25),
                new Person("贝吉塔", 20),
                new Person("龟仙人", 30)
        };

        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getAge() - p2.getAge();
            }
        });

        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

贝吉塔- 20
卡卡罗特 - 25
龟仙人 - 30

=============================================================================
public class Demo03 {
    public static void main(String[] args) {
        Person[] people = {
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Charlie", 30)
        };
  		// 使用Lambda表达式替换匿名内部类实现Comparator接口
        Arrays.sort(people, (p1, p2) -> p1.getAge() - p2.getAge());

        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

在这个例子中，我们定义了一个 Person 类，并创建了一个 Person 对象数组。然后，我们使用匿名内部类来实现 Comparator 接口，并在其中重写了 compare() 方法。该方法根据人物的年龄进行比较。最后，我们使用 Arrays.sort() 方法对人物数组进行排序，并输出排序后的结果。

以上就是三个例子，它们展示了如何在 Java 中使用 Comparator 接口进行自定义排序。

2.使用 Comparable 接口

import java.util.Arrays;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        // 按照年龄进行比较
        return this.age - other.age;
    }
}

public class Demo04 {
    public static void main(String[] args) {
        Person[] people = {
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Charlie", 30)
        };

        Arrays.sort(people);

        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

使用Comparable接口主要适用于单一的比较规则，而Comparator接口对于需要多种或动态比较规则的情况更为常用。

实战例题：（后续更新）

喻师傅
关注
  • 31
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MySQL按常规排序、自定义排序和按中文拼音字母排序的方法
01-19
MySQL常规排序、自定义排序和按中文拼音字母排序，在实际的SQL编写时，我们有时候需要对条件集合进行排序。 下面给出3种比较常用的排序方式，mark一下 1.常规排序ASC DESC ASC 正序 DESC倒叙 — 此处不用多讲 2....
Java_15:排序和搜索
05-18
Learn_core_java_day_15 第一天：Java编程基础知识 第二天：变量，数据类型和赋值。 第三天：更多变量/类型转换 第四天：介绍对象 ...第18天：使用Java Swing进行GUI编程 第19天：接口和继承。 第20天：Web服务
java 自定义排序实现
qq_53844452的博客
08-13 542
自定义排序实现的两种方法 lambda表达式介绍
java自定义排序
qq_45733304的博客
04-23 6789
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实现的短语搜索，支持公司名称、地址名称等短语的搜索，支持自定义排序、拼音处理，内置jetty提供web接口
09-18
基于Java实现的短语搜索，支持公司名称、地址名称等短语的搜索，支持自定义排序、拼音处理，内置jetty提供web接口 使用方法： cd phrase-search unix类操作系统执行： chmod +x startup.sh & ./startup.sh windows类操作系统执行(双击)： startup.bat 打开浏览器访问: http://localhost:8080/index.jsp JSON格式的API接口: http://localhost:8080/search-api.jsp?kw=%E6%B7%B1%E5%9C%B3%E8%85%BE%E8%AE%AF&topN=10&highlight=true
Java Arrays.sort()的使用以及 Comparable接口和Compartor接口的对比
weixin_37613476的博客
07-30 531
@[TOC](Java Arrays.sort()的使用以及 Comparable接口和Compartor接口的对比) Arrays.sort(Objetc[] a) 对对象数组a进行自然排序，Object对象必须实现了Comparable接口，重写comparTo方法 对于String,包装类等，底层实现了Comparable接口，重写了compareTo方法，所以可以直接使用，默认是从小到大的方式排序 对于compareTo方法的重写规则: 如果当前对象大于形参obj, 返回正整数，表示从小到大 如果当
最全的Java中Arrays.sort()与Collections.sort()底层原理和字符串比较排序分析
mysql表名与列名单引号‘’引发的错误
02-10 1850
如果我们直接调用Arrays.sort()与Collections.sort()排序自然是升序排序出来，但是我们经常需要自己去定义些排序的规则，由于我们对底层原理不是很清楚导致我们无法改写排序规则。同时假如给你一个字符串怎了比较排序或是自定义排序？ 针对上面问题所以想全面总结下怎么自如的运用Arrays.sort()与Collections.sort()做个分析。 首先我们从三个方面来解...
Java中自定义排序的几种方式
heyong的博客
08-20 9874
一、普通类型数组int[] 对于普通数据类型数组，Java的Arrays类中提供了几种方法： Arrays.sort(int[] a)：按照数字顺序排列指定的数组 sort(int[] a, int fromIndex, int toIndex)：按升序排列数组的指定范围 Arrays.parallelSort(int[] a) ：按照数字顺序排列指定的数组 Arrays.parallelSort(int[] a, int fromIndex, int toIndex) ：按照数字顺序排列数组的指定范围
Java 自定义排序
yake1965
12-12 1万+
java sort Comparable Comparable 可以认为是一个内比较器，实现了 Comparable 接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了 Comparable 接口的类如何比较，则依赖 compareTo 方法的实现，compareTo 方法也被称为自然比较方法。如果开发者 add 进入一个 Collection 的对象想要 Collections 的 sort 方法帮你自动进行排序的话，那么这个对象必须实现 Comparable 接口。compareT
【Java】自定义排序
小威的博客
01-28 2071
文章目录数组lambdaComparator列表List返回值规律 数组 lambda Arrays.sort(properties, (o1, o2) -> { return o1[0] == o2[0] ? (o2[1] - o1[1]) : (o1[0] - o2[0]); }); 按第0维升序排序，第0维相同时按第1维降序排序。 e.g. int[][] arr = {{1, 5}, {10, 4}, {4, 3}, {4, 4}}; System.out.println(Arrays.d
【已解决】JAVA如何实现自定义排序
执念斩长河
01-10 762
本博文源于笔者日常学习，要想在java中自定义排序，只需要重写compare函数就行。这里就以整数数组为例。
详解JAVA使用Comparator接口实现自定义排序
08-26
主要介绍了JAVA使用Comparator接口实现自定义排序，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java集合-TreeSet的使用
06-14
TreeSet 是 Java 中的一个集合类，它实现了 SortedSet 接口，并且使用红黑树作为底层数据结构。TreeSet 具有以下主要特点： 排序性：TreeSet 中的元素是有序的，默认按照元素的自然顺序进行排序。或者，可以在创建 ...
java8 List 实用方法App.java
05-19
实用方法，使用java8 stream对List 分组，去重，自定义排序
Arrays.sort()
精神病有所好转的博客
09-07 1627
通常情况下，我们通常直接使用此方法对数组等进行排序，其实还有一种自定义比较器制定比较规则的方法： sort(T[] a, Comparator&lt;? super T&gt; c)  继承此方法的时候，要自定义比较器，conpareTo方法返回值为1(升序),0，-1(降序)。 举个栗子：         输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最...
java自定义类实现指定规则的排序：Comparator接口、Comparable接口、CompareTo（）、Compare（）
YiGeiGiaoGiao的博客
03-01 2899
自定义类想进行排序，需要实现Comparable接口，否则在排序的时候，会出现向下转型失败！（可以看源码，知道在map的put方法的时候）
Java数组排序Arrays.sort，以及Comparator接口的用法
热门推荐
giianhui的专栏
06-06 3万+
有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法，但既然java包里有自带的Arrays.sort排序方法，在 数组元素比较少的时候为何不用？ 　　Sorting an Array 1. 数字排序  int[] intArray = new int[] { 4, 1, 3, -23 };　　Arrays.sort(intArray);　　输出： [-23, 1, 3, 4]　　2. 字符串排序，先大写后小写 String[] strArray = new String[]
【java】基本类型、自定义类型set集合的多种排序方式：lambda表达式排序、JDK API、Java8 stream流
想念是会呼吸的痛~
02-08 3002
【java】基本类型、自定义类型set集合的多种排序方式：lambda表达式排序、JDK API、Java8 stream流
java 自定义排序
最新发布
10-11
可以使用Java中的Comparator接口来自定义排序。Comparator接口包含一个compare方法，该方法用于比较两个对象的顺序。下面是一个示例代码，展示如何使用Comparator来自定义排序： ```java import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; class Student { private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } public class Main { public static void main(String[] args) { List<Student> students = new ArrayList<>(); students.add(new Student("Alice", 20)); students.add(new Student("Bob", 18)); students.add(new Student("Charlie", 22)); // 使用匿名内部类实现Comparator接口 Comparator<Student> ageComparator = new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { return s1.getAge() - s2.getAge(); } }; // 根据年龄升序排序 Collections.sort(students, ageComparator); for (Student student : students) { System.out.println(student.getName() + " - " + student.getAge()); } } } ``` 输出结果： ``` Bob - 18 Alice - 20 Charlie - 22 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喻师傅

谢谢您！我会继续努力创作！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值