Comparable接口与Comparator接口

最新推荐文章于 2024-03-15 21:37:50 发布
最新推荐文章于 2024-03-15 21:37:50 发布
阅读量425 收藏 3
点赞数
分类专栏： Java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185543/article/details/102468227
版权

Comparable接口与Comparator接口
1.Comparable（内部排序接口）简介：
若一个类实现了Comparable接口，就意味着“该类支持排序”。既然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表（或数组）”，则该List列表（或数组）可以通过Collections.sort（或Arrays.sort)进行排序。
此外，“实现Comparable接口的类的对象”可以用做“有序映射TreeMap”中的键或“有序集合TreeSet”中的元素，而不需要指定比较器。
Comparable定义：
Comparable接口仅仅包括一个函数，它的定义如下：
public interface Comparable{
public int compareTo(T o);
}
关于返回值
可以看出CompareTo方法返回一个int值，该值有三种返回值：
1.返回负数：表示当前对象小于比较对象，
2.返回0：表示当前对象等于目标对象，
3.返回正数：表示当前对象大于目标对象。
2.Comparator(外部排序接口)简介：
Comparator是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序（即没有实现Comparable接口）；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Coparator接口即可。
也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对垒进行排序。
Comparator定义：
Comparator接口仅仅只包括两个函数，它的定义如下：
public interface Comparator{
int compare(T o1,T o2);
boolean equals(Object obj);
}
int compare(T o1,T o2);是比较o1和o2的大小。返回负数，意味着o1比o2小；返回0，意味着o1等于o2；返回正数，意味着意味着o1比o2。
3.Comparator和Comparable比较
Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
4.说明：

  1. String已经实现过Comparable；
    Integer已经实现过Comparable。
  2. 对象无法带有顺序，不能使用<,=,>，如何让解决这个问题呢？
    两种办法：
    2.1自然顺序： 类实现Comaprable接口
    使用方式：
    p.comapreTo(q);
    2.2非自然顺序：定义一个比较器(实现Comaprator类)
    使用方式：
    Comparator 比较器=new …;
    比较器.compare(p,q);
  3. 泛型接口：
    3.1 Comaprable<>
    class Person implements Comparable
    //1.定义了Person类
    //2.Person具备自然顺序
    //3.Person类的自然顺序是需要和一个Person比较
    3.2 Comparator<>
    class PersonHeightComparator implements Comparator
    //1.定义了一个比较器类，名字是PersonHeightComparator
    //2.这个比较器负责Person类型的比较
  4. 有Comparable为何还要引入Comparator？
    有些天生没有自然顺序，或者自然顺序比满足我们的需要，所以需要引入比较器来做比较。
    示例1：
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

class Person {
	private String name;
	private Integer age;

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

	public String toString() {
		return "Person{" + "name='" + name + '\'' + ",age=" + age + '}';
	}

	public String getName() {
		return name;
	}

	public void setName() {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge() {
		this.age = age;
	}
}

class AscAgeComparator implements Comparator<Person> {
	public int compare(Person o1, Person o2) {
		return o1.getAge() - o2.getAge();
	}
}

class DescAgeComparator implements Comparator<Person> {
	public int compare(Person o1, Person o2) {
		return o2.getAge() - o1.getAge();
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Set<Person> set = new TreeSet<>(new AscAgeComparator());
		set.add(new Person("张三", 20));
		set.add(new Person("李四", 18));
		System.out.println(set);
		Set<Person> set2 = new TreeSet<>(new DescAgeComparator());
		set2.add(new Person("张三", 20));
		set2.add(new Person("李四", 18));
		System.out.println(set2);
	}
}

运行结果：
在这里插入图片描述
示例2：


import java.util.Comparator;
class PersonHeightComparator implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        return (int)(o1.height-o2.height);
    }
}
class PersonNameComparator implements Comparator<Person>{

    @Override
    //把Person1的name取出来，并用Person1的自然顺序为比较顺序
    public int compare(Person o1, Person o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Person implements Comparable<Person>{
    public String name;
    public int age;
    public double height;
    public int weight;
    public int level;
    public int gender;

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

    @Override
    public int compareTo(Person o) {
        return age-o.age;
        /*
        if(age<o.age){
            return -1;
        }else if(age==o.age){
            return 0;
        }else if(age>o.age){
            return 1;
        }
        */
    }
    
//设计一个复杂比较器，比较顺序依次为身高、体重、姓名、年龄
    class ComplexComparator implements Comparator<Person>{
        @Override
        public int compare(Person o1, Person o2) {
            if(o1.height<o2.height){
                return -1;
            }else if(o1.height>o2.height){
                return 1;
            }
            if(o1.weight<o2.weight){
                return -1;
            }else if(o1.weight>o2.weight){
                return 1;
            }
            int n=o1.name.compareTo(o2.name);
            if(n!=0){
                return n;
            }
            return o1.age-o2.age;
        }
    }
    
    public static void main(String[] args) {
        Person p=new Person("James",18,185.0);
        Person q=new Person("Tom",20,180.2);
        //按照年龄比较
        System.out.println("按照年龄比较：");
        int a=p.compareTo(q);
        if(a<0){
            System.out.println("p小于q");
        }else if(a==0){
            System.out.println("p等于q");
        }else{
            System.out.println("p大于q");
        }

        Comparator<Person> comparator=new PersonNameComparator();
        //按照姓名比较
        System.out.println("按照姓名比较：");
        int n=comparator.compare(p,q);
        if(n<0){
            System.out.println("p小于q");
        }else if(n==0){
            System.out.println("p等于q");
        }else{
            System.out.println("p大于q");
        }

        comparator=new PersonHeightComparator();
        //基于身高的比较
        System.out.println("按照身高比较：");
        int h=comparator.compare(p,q);
        if(h<0){
            System.out.println("p小于q");
        }else if(h==0){
            System.out.println("p等于q");
        }else{
            System.out.println("p大于q");
        }

        //额外的验证用例：String和Integer已经实现过Comparable
        System.out.println("额外的验证用例：体现String已经实现过Comparable：");
        System.out.println("abc".compareTo("bbc"));
        System.out.println("abc".compareTo("abcd"));
    }
}

运行结果：
在这里插入图片描述
示例3.1：下例的前奏


import java.util.Comparator;

public class Student {
    static class Sort{
        static void insertSort(Student[] students){
            for(int i=1;i<students.length;i++){
                Student k=students[i];
                int j=i-1;
                for(; j>0&&((Comparable<Student>)students[j]).compareTo(k)>0; j--){
                    students[j+1]=students[j];
                }
                students[j+1]=k;
            }
        }

        static void insertSort(Student[] students,Comparator<Student> cmp){
            for(int i=1;i<students.length;i++){
                Student k=students[i];
                int j=i-1;
                for(; j>0&&cmp.compare(students[j],k)>0; j--){
                    students[j+1]=students[j];
                }
                students[j+1]=k;
            }
        }
    }

    public String sn;
    public String name;
    public int age;

    public static class Cmp implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return 0;
        }
    }
    
    public static void main(String[] args) {
        Student[] students={new Student()};
        Sort.insertSort(students,new Cmp());
    }
}

示例3.2：和图书排序有关的联系


import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Book implements Comparable<Book>{
    String ISBN;
    String title;
    String author;
    int price;
    int sales;
    int comments;

    public Book(String ISBN, String title, String author, int price, int sales, int comments) {
        this.ISBN = ISBN;
        this.title = title;
        this.author = author;
        this.price = price;
        this.sales = sales;
        this.comments = comments;
    }

    @Override
    public int compareTo(Book o) {
        return 0;
    }

    @Override
    public String toString() {
        return "Book{" +
                "ISBN='" + ISBN + '\'' +
                ", title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", sales=" + sales +
                ", comments=" + comments +
                '}';
    }
    
    static class Sort {
        public static void sort(List<Book> books) {
            for (int i = 1; i < books.size(); i++) {
                Book book = books.get(i);
                int j = i - 1;
                for (; j >= 0 && books.get(j).compareTo(book) > 0; j--) {
                    books.set(j + 1, books.get(j));
                }
                books.set(j + 1, book);
            }
        }
        public static void sort(List<Book> books, Comparator<Book> comparator) {
            for (int i = 1; i < books.size(); i++) {
                Book book = books.get(i);
                int j = i - 1;
                for (; j >= 0 && comparator.compare(books.get(j), book) > 0; j--){
                    books.set(j + 1, books.get(j));
                }
                books.set(j + 1, book);
            }
        }
    }

    static class TitleComparator implements Comparator<Book> {
        @Override
        public int compare(Book o1, Book o2) {
            return o1.title.compareTo(o2.title);
        }
    }

    static class PriceComparator implements Comparator<Book>{
        /**
         * true代表从小到大，false代表从大到小
         */
        boolean asc;

        public PriceComparator(boolean asc) {
            this.asc = asc;
        }


        @Override
        public int compare(Book o1, Book o2) {
            if(asc){
                return o1.price-o2.price;
            }else{
                return o2.price-o1.price;
            }
        }
    }
        public static void main(String[] args) {
            List<Book> books = new ArrayList<>();
            books.add(new Book("9787201151304", "从一到无穷大", "[美] 乔治·伽莫夫", 1600, 400, 26));
            books.add(new Book("9787020147465", "应物兄", "李洱", 7900, 1668, 300));
            books.add(new Book("9787220107085", "如何写甲骨文", "日本文字文化机构", 8800, 23, 6));
            books.add(new Book("9787521706635", "敌人与邻居", "[英]伊恩·布莱克", 10800, 3, 0));
            books.add(new Book("9787301280751", "法国大革命 (第2版)", "布兰宁(T.C.W.Blanning)", 4500, 1993, 188));

            List<Book> copy;

            // 按自然顺序（ISBN）排序
            System.out.println("按 ISBN 排序：");
            copy = new ArrayList<>(books);
            Sort.sort(copy);
            System.out.println(copy);

            // 按书名排序
            System.out.println("按 书名 排序：");
            copy = new ArrayList<>(books);
            Sort.sort(copy, new TitleComparator());
            System.out.println(copy);

            // 按价格排序-从小到大
            System.out.println("按 价格-从小到大 排序：");
            copy = new ArrayList<>(books);
            Sort.sort(copy, new PriceComparator(true));
            System.out.println(copy);

            // 按价格排序-从大到小
            System.out.println("按 价格-从大到小 排序：");
            copy = new ArrayList<>(books);
            Sort.sort(copy, new PriceComparator(false));
            System.out.println(copy);
        }
}

运行结果：
在这里插入图片描述

hi168
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Comparable接口和Comparator接口
桐花思雨
12-06 694
目录前言`Comparable` 接口 前言 在实际应用中，我们往往有需要 比较两个自定义对象 大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以 Java 中要 比较对象的大小 或者要 对对象的集合 进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系 一般 Java 中通过接口来实现两个对象的比较，比较常用就是 Comparable 接口和Comparator 接口 Comparable 接口
Comparator和Comparable的区别
热门推荐
m0_71087031的博客
05-18 1万+
文章目录 一、概述 二、Comparable 三、Comparator 四、Comparator和Comparable的区别 五、实现方式 一、概述   Comparable和Comparator都是两个接口，接口都可以用来实现集合中元素的比较、排序，Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而Comparator既可以嵌入到自身类中，也可以在一个独立的
Comparable和Comparator接口
j871536764的博客
01-04 137
Comparable和Comparator接口
傻傻的分不清 Comparator 和 Comparable 接口? 两分钟弄懂~
CYK_byte的博客
04-19 1103
依赖于 compareTo 方法进行比较，该方法只有一个参数，就是要比较的对象。怎么使用呢？例如我们有一个 Student 类，需要按照年龄进行升序排序，那么就可以让该类实现 comparable 接口，重写 compareTo 方法，比较规则为按照年龄大小升序进行排序，如下代码：Ps：这里升序还是降序，到底是用谁减谁？不用死记，每次用之前自己试一下，试多了自然清楚.
Comparable接口与Comparator接口的使用
qq_45331503的博客
02-08 243
这两个接口适用于排序 Comparable接口和Comparator接口的区别 Comparable接口位于java.lang包下；Comparator位于java.util包下 Comparable接口只提供了一个compareTo()方法；Comparator接口不仅提供了compara()方法，还提供了其他默认方法，如reversed()、thenComparing()，使我们可以按照更多的方式进行排序 如果要用Comparable接口，则必须实现这个接口，并重写comparaTo()方法
Java 比较接口comparable与comparator区别解析
08-25
Java 比较接口comparable与comparator区别解析 Java 语言中提供了两个比较接口： Comparable 和 Comparator，这两个接口都是用于比较对象的大小顺序的，但它们有着不同的使用场景和实现方式。在本文中，我们将详细...
Comparable接口和Comparator接口的比较
12-20
Comparable接口和Comparator接口是Java中用于排序的关键组件，它们在数据结构如数组、集合和映射的排序过程中扮演着重要角色。接下来我们将深入探讨这两个接口的特性、用途以及它们之间的区别。 1. Comparable接口...
浅析Java中comparator接口与Comparable接口的区别
09-01
在Java编程语言中，Comparable和Comparator接口都用于比较对象，但它们之间存在一些关键区别，这对于理解和优化代码的可扩展性至关重要。 首先，Comparable接口是一个排序接口，它定义了一个单一的方法`compareTo(T...
详解Java中Comparable和Comparator接口的区别
08-29
主要介绍了详解Java中Comparable和Comparator接口的区别的相关资料,希望通过本文大家能彻底掌握这部分内容，需要的朋友可以参考下
comparator接口与Comparable接口的区别
07-13
comparator接口与Comparable接口的区别
Java Comparable及Comparator接口区别详解
08-18
Java Comparable及Comparator接口区别详解 Java 中的 Comparable 和 Comparator 接口都是用来比较对象大小的，但是它们之间有着非常重要的区别。 首先，让我们来了解一下 Comparable 接口。Comparable 接口位于 ...
Comparable接口和Comparator使用示例
06-09
与 Comparable 接口不同，Comparator 是一个外部比较器，它可以独立于被比较的对象。 在上面的示例代码中，我们定义了一个 CompareTest 类，该类实现了 Comparator 接口。CompareTest 类用于比较两个 Simple 对象的...
Comparator 和 Comparable接口
memory
07-26 160
1. Comparator 和 Comparable作用 Comparator 和 Comparable作用：都是java的接口, 并且是用来对自定义的class比较大小的。 当我们自己定义了一个对象Student： public class Student { int score; int age; } 有这么一个studentList,里面包含了student1,...
Comparable接口与Comparator 接口详解
最新发布
wwwwwmmn的博客
03-15 735
Comparable 接口和 Comparator 接口都是 Java 中用于比较对象的接口，但它们在使用方式和场景上有所不同。
详解Comparable接口与Comparator接口的使用及区别
lengyu15的博客
10-30 513
详细分析和讲解了Comparable接口和Comparator接口的具体使用和区别
深度解析Java中的Comparable接口和Comparator接口
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5710
给学生对象数组排序的两种方法——Comparable接口和Comparator接口
Java基础篇 —Comparable接口与Comparator接口的使用及区别
m0_63330888的博客
04-13 1623
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言概念 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了.
comparable接口和comparator
03-16
"Comparable" 接口和 "Comparator" 接口都是用于排序的接口，但它们在实现方式和作用上略有不同。 "Comparable" 接口是 Java 中的一个内置接口，用于实现对象的自然排序。如果一个类实现了 "Comparable" 接口，那么...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值