Java中的自然排序

最新推荐文章于 2024-08-13 09:54:51 发布
原创 最新推荐文章于 2024-08-13 09:54:51 发布 · 490 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

博客给出Java编程例题，要求编写一个类，对其成员变量按多种规则进行自然排序。包括直接实现接口按年龄从小到大排序，利用接口通过匿名内部类实现从大到小、按对象长短排序，还需综合排序，用表达式指向方法。

例题

编写一个Dog类。其成员变量有：

int age;
String name;
double price;

按以下要求进行自然排序：

  • 直接实现Comparable接口，按照年龄从小到大对Dog数组进行自然排序
package com.cskaoyan.comparatorhomework;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        //创建数组
        Dog[] dogs = new Dog[7];

        //创建对象
        dogs[0] = new Dog(4,"柯基",1300);
        dogs[1] = new Dog(4,"花花",800);
        dogs[2] = new Dog(3,"边牧",1500);
        dogs[3] = new Dog(5,"哈士奇",1100);
        dogs[4] = new Dog(2,"拉布拉多",1500);
        dogs[5] = new Dog(2,"中华田园犬",2000);
        dogs[6] = new Dog(6,"小狐狸",700);

        //排序
        Arrays.sort(dogs);
        //输出
        for (Dog d : dogs) {
            System.out.println(d);
        }

    }
}

class Dog implements Comparable{
    //成员变量
    int age;
    String name;
    double price;

    //三参构造器
    public Dog(int age, String name, double price) {
        this.age = age;
        this.name = name;
        this.price = price;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    //实现Comparable接口,重写compareTo方法
    public int compareTo(Object o) {
        //按照年龄的大小从小到大排序
        //这里出现了强转,使用泛型可以不写强转
        return age - ((Dog) o).age;
    }
}

在这里插入图片描述

  • 利用Comparator接口，用匿名内部类和lambda分别对Dog数组进行自然排序。
    ①按照price从大到小排序
package com.cskaoyan.comparatorhomework;

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

public class Demo {
    public static void main(String[] args) {
        //创建数组
        Dog[] dogs = new Dog[7];

        //创建对象
        dogs[0] = new Dog(4,"柯基",1300);
        dogs[1] = new Dog(4,"花花",800);
        dogs[2] = new Dog(3,"边牧",1500);
        dogs[3] = new Dog(5,"哈士奇",1100);
        dogs[4] = new Dog(2,"拉布拉多",1500);
        dogs[5] = new Dog(2,"中华田园犬",2000);
        dogs[6] = new Dog(6,"小狐狸",700);

        //排序 匿名内部类
        //Comparator接口,重写compare方法
        //<Dog>是泛型,可以省略强转
        Arrays.sort(dogs, new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                //price是double类型,需要强转为int
                return (int) (o2.price - o1.price);
            }
        });
        //输出
        for (Dog d : dogs) {
            System.out.println(d);
        }
    }
}

class Dog{
    //成员变量
    int age;
    String name;
    double price;

    //三参构造器
    public Dog(int age, String name, double price) {
        this.age = age;
        this.name = name;
        this.price = price;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

在这里插入图片描述

②按照name的长短排序，name越长对象越大

package com.cskaoyan.comparatorhomework;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        //创建数组
        Dog[] dogs = new Dog[7];

        //创建对象
        dogs[0] = new Dog(4,"柯基",1300);
        dogs[1] = new Dog(4,"花花",800);
        dogs[2] = new Dog(3,"边牧",1500);
        dogs[3] = new Dog(5,"哈士奇",1100);
        dogs[4] = new Dog(2,"拉布拉多",1500);
        dogs[5] = new Dog(2,"中华田园犬",2000);
        dogs[6] = new Dog(6,"小狐狸",700);

        //排序 lambda表达式
        /*Arrays.sort(dogs,(d1,d2) -> {
            return d2.name.length() - d1.name.length();
        });*/
        //以上代码可以压行:去掉return和大括号
        Arrays.sort(dogs,(d1,d2) -> d2.name.length() - d1.name.length());
        //输出
        for (Dog d : dogs) {
            System.out.println(d);
        }
    }
}

class Dog{
    //成员变量
    int age;
    String name;
    double price;

    //三参构造器
    public Dog(int age, String name, double price) {
        this.age = age;
        this.name = name;
        this.price = price;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

在这里插入图片描述

  • 综合age，name，price进行排序，要求用lambda表达式指向一个方法。 排序的规则是age越小对象越小，age相同比较name长短，name越短对象越小，name长度也相等，比较price，price越大对象越小
package com.cskaoyan.comparatorhomework;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        //创建数组
        Dog[] dogs = new Dog[7];

        //创建对象
        dogs[0] = new Dog(4,"柯基",1300);
        dogs[1] = new Dog(4,"花花",800);
        dogs[2] = new Dog(3,"边牧",1500);
        dogs[3] = new Dog(5,"哈士奇",1100);
        dogs[4] = new Dog(2,"拉布拉多",1500);
        dogs[5] = new Dog(2,"中华田园犬",2000);
        dogs[6] = new Dog(6,"小狐狸",700);

        //排序
        //lambda表达式 类名::方法名
        Arrays.sort(dogs,Demo::myCompara);
        //输出
        for (Dog d : dogs) {
            System.out.println(d);
        }

    }

    //排序的规则:从小到大排序
    //age越小对象越小,age相同比较name长短
    //name越短对象越小,name长度也相等,比较price
    //price越大对象越小
    public static int myCompara(Dog d1,Dog d2){
        if (d1.age != d2.age){
            return d1.age - d2.age;
        }

        if (d1.name != d2.name){
            return d1.name.length() - d2.name.length();
        }

        //代码执行到这里说明age相等且name的长度相等
        //price是double,需要强转为int
        return (int) (d2.price - d1.price);
    }
}

class Dog{
    //成员变量
    int age;
    String name;
    double price;

    //三参构造器
    public Dog(int age, String name, double price) {
        this.age = age;
        this.name = name;
        this.price = price;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

在这里插入图片描述

Java自然排序（个人总结-求赞）
Monster__Day的博客
07-20 6036
这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Comparabl
Java中自然排序和比较器排序详解
09-01
在Java编程中，排序是我们经常遇到的任务，而自然排序和比较器排序是两种重要的对象排序方式。本文将深入讲解这两种排序方法，并通过实例代码进行演示。 首先，自然排序是指实现了`java.lang.Comparable`接口的类...
JAVA - 自然排序 Comparable
jc15274630894的博客
08-01 711
JAVA --- 自然排序 Comparable
Java常用类————排序：自然排序Comparable；定制排序Comparator
Jrthur_A的博客
06-14 3002
java排序：Comparator接口和Comparable接口的实现
【java】深入理解自然排序
m0_71563599的博客
06-04 811
对于int数组，字符串数组来说，他们是很容易比较大小的。你可以自己写一个快排算法，或者直接调用java中的排序接口Arrays.sort()来实现对数组的排序。但如果我们想对对象数组进行排序，该怎么做呢，java身为一个面向对象的语言，自然不会留下这样的缺漏，我们甚至仍旧可以对对象数组调用Arrays.sort()方法，实现排序功能，这就是所谓的java自然排序。 /* 普通数组的排序 */ public static void main(String[] args) { String[] strs
java基础 之 自定义类的排序：自然排序 和 定制排序
oneouto的博客
08-13 1212
自定义类的排序：了解自然排序 和 定制排序
java 中文姓氏 排序
11-15
本文将详细介绍如何在 Java 中对包含中文姓氏的对象列表或字符串列表进行排序。 #### 二、基本概念 1. **Collator 类**：这是 Java 中用于文本排序和检索的标准类。`Collator` 类提供了与语言环境相关的字符串排序...
简单了解java自定义和自然排序
08-25
自然排序和自定义排序都是 Java 中的排序方法。自然排序需要参与排序的对象实现 `Comparable` 接口，并重写其 `compareTo()` 方法。自定义排序需要编写匿名内部类，实现 `Comparator` 接口，并重写其 `compare()` ...
java使用stream对日期排序
11-17
这里，`Comparator.naturalOrder()`是根据日期的自然顺序进行排序，即按年、月、日依次比较。如果需要自定义排序规则，可以创建一个`Comparator<LocalDate>`实例。 4. 自定义日期排序： 如果需要按照特定规则...
Java自然排序Comparable使用方法解析
08-19
Java自然排序Comparable使用方法解析 Java中的自然排序是指使用Comparable接口来实现对象的排序，通过重写compareTo方法来控制排序结果。Comparable接口是Java中的一个接口，用于定义对象的自然顺序。它只有一个...
【Java 基础篇】Java 自然排序：使用 Comparable 接口详解
繁依Fanyi的博客
09-13 9318
自然排序是一种默认的对象排序方式，它是根据对象的内在特征或属性来排序的。例如，对于整数，自然排序是按照数字的大小进行排序；对于字符串，自然排序是按照字母的字典顺序进行排序。自然排序通常是最直观和常见的排序方式，它使得对象在集合中以一种有序的方式存储和检索。在 Java 中，自然排序是通过Comparable接口来实现的。这个接口定义了一个compareTo方法，允许对象自己来决定如何与其他对象进行比较。Comparable接口是一个泛型接口，通常在类的声明中使用泛型参数来指定需要比较的对象类型。
java排序比较_Java中自然排序和比较器排序详解
weixin_42517317的博客
02-12 336
前言当指执行插入排序、希尔排序、归并排序等算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口java.lang.Comparable和java.util.Comparator。...
java-----TreeSet实现自然排序
weixin_42981168的博客
03-14 601
1,什么叫自然排序 Comparable接口，此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序 只有一个方法 int compareTo(T t) 该方法的返回值,有三种可能 负整数:小于指定对象 零:等于制定对象 正整数:大于制定对象 2,注意,一般情况下,不要add()null值,null其实是可以存放的，但是要避免出现空指针异常，这个问题是很容易出现的。如果不实现Co...
java集合进行排序的两种方式--自然排序和定制排序
weixin_45077780的博客
07-06 1030
java集合的工具类Collections中提供了两种排序的方法,分别是: Collections.sort(List list) Collections.sort(List list,Comparator c) 第一种称为自然排序,参与排序的对象需实现comparable接口,重写其compareTo()方法,方法体中实现对象的比较大小规则,示例如下: 实体类:(基本属性,getter/setter方法,有参无参构造方法,toString方法) package test; public class
【简单】自然数数组的排序－Java：解法一
了解➔熟悉➔掌握➔精通
01-30 740
package live.every.day.ProgrammingDesign.CodingInterviewGuide.ArrayAndMatrix; import java.util.Arrays; /** * 自然数数组的排序 * * 【题目】 * 给定一个长度为N的整型数组arr，其中有N个互不相等的自然数1~N，请实现arr的排序，但是不要把下标0~N-1位置上的数通过直接 * 赋值的方式替换成1~N。 * * 【要求】 * 时间复杂度为O(N)，额外空间复杂度为O(1)。
自然排序java_探究Java自然排序算法
weixin_35259353的博客
02-26 395
natSort说明现实生活中有很多场景需要用到“自然排序”的算法，比如对金钱表示的排序：“￥165.2，￥-365.03，￥+0.80”，还比如对日志文件名称排序“version1.0.log，version1.1.log1，version01.1.log2”等。这种情况下使用常规的字符串排序得到的结果是与实际业务不符合的，即使查阅了一些第三方的开源框架，也没有找到很好解决这个问题的方式(主要是业...
Java 自然排序与比较器排序
qq_32468603的博客
04-22 1660
自然排序与比较器排序 自然排序(Comparable) java.lang.Comparable; Comparable是一个抽象类，需要类实现它，才可以使用自然排序。 Comparable 同时是泛型，需要实现它的public int compareTo()方法. 以TreeSet举例，TreeSet有两种使用排序的方法，一种是类型自带自然排序接口Comparable，如：Integer，String等，都是实现了Comparable接口，所以可以直接添加对象进TreeSet中，TreeSet通过他们本身
JAVA中的自然排序以及定制排序
weixin_49726760的博客
05-17 746
JAVA中的自然排序以及定制排序 自然排序： 需要实现comparable接口，重写接口中的compareTo方法。实现此接口的对象列表（和数组）可以通过Collections.sort（和 Arrays.sort）进行自动排序 compareTo方法返回值为int。当大于0时表示，当前对象大于传入对象。小于0是表示当前对象小于传入对象。0表示两者相等。 举例：我们定义一个EMP类，按照其名称进行排序 package test; public class Emp implements Comparable
java中自然排序和比较器排序
09-19 1486
这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Comparabl
JAVA中自然排序与定制排序
最新发布
01-06
### Java 中自然排序与定制排序 #### 自然排序 (Comparable) 在 Java 中，当对象实现了 `Comparable` 接口并覆写了 `compareTo()` 方法时，则该类的对象可以进行自然排序。这意味着这些对象能够按照某种默认顺序排列。 对于基本数据类型的数组以及实现了 `Comparable` 的对象数组可以直接调用 `Arrays.sort()` 进行升序排序[^1]： ```java import java.util.Arrays; class NaturalSortExample { public static void main(String[] args) { Integer arr[] = {-61, 10, -1, 7, 0, 89}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); } } ``` 上述代码会输出 `-61, -1, 0, 7, 10, 89` 表明整数已经按从小到大的顺序进行了排序[^3]。 如果希望自定义的类也支持这种行为，那么就需要让这个类实现 `Comparable<T>` 并提供具体的比较逻辑[^2]。 #### 定制排序 (Comparator) 相比之下，通过实现 `Comparator` 接口的方式更加灵活多变。这种方式允许开发者创建独立于被比较对象之外的比较器实例，在不修改原有类的情况下改变其排序规则[^4]。 下面是一个简单的例子展示了如何利用 Comparator 来完成降序排序: ```java import java.util.Arrays; import java.util.Comparator; class CustomComparator implements Comparator<Integer> { @Override public int compare(Integer o1, Integer o2) { return o2.compareTo(o1); // 反转参数位置以达到倒序效果 } } public class Main { public static void main(String[] args){ Integer arr[] = {-61, 10, -1, 7, 0, 89}; Arrays.sort(arr,new CustomComparator()); System.out.println(Arrays.toString(arr)); } } ``` 这段程序将会打印出 `[89, 10, 7, 0, -1, -61]`, 显示了列表中的元素已被成功反转为从大到小排列. #### 主要差异 - **适用范围**: 如果想要给某个特定类型设置固定的全局排序标准，应该优先考虑使用 Comparable；而当你只需要临时调整某些场景下的排序策略而不影响其他部分的行为模式时，Comparator 是更好的选择。 - **灵活性**: 使用 Comparator 不仅可以在运行期间动态指定不同的排序算法，还可以轻松处理更复杂的条件组合，例如基于多个字段联合判断先后次序等问题. - **侵入性**: 实现 Comparable 要求目标类本身做出改动，这可能会影响到整个系统的结构设计；相反地，借助外部 comparator 则完全不会干扰原始实体内部的状态维护机制.
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值