Comparable接口与Comparator接口

最新推荐文章于 2022-10-15 17:02:32 发布
最新推荐文章于 2022-10-15 17:02:32 发布
阅读量424 收藏 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
    评论
专栏目录
Java 比较接口comparable与comparator区别解析
08-25
Java 比较接口comparable与comparator区别解析 Java 语言中提供了两个比较接口： Comparable 和 Comparator，这两个接口都是用于比较对象的大小顺序的，但它们有着不同的使用场景和实现方式。在本文中，我们将详细...
Comparable接口和Comparator接口的比较
12-20
Comparable接口和Comparator接口是Java中用于排序的关键组件，它们在数据结构如数组、集合和映射的排序过程中扮演着重要角色。接下来我们将深入探讨这两个接口的特性、用途以及它们之间的区别。 1. Comparable接口...
Java基础篇 —Comparable接口与Comparator接口的使用及区别
m0_63330888的博客
04-13 1623
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言概念 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了.
Java中Comparable和Comparator的使用
qq_51753787的博客
06-08 774
Java中Comparable和Comparator的使用方法总结
comparable和comparator接口
qq_46664839的博客
03-21 267
作用 Comparable和Comparator两个接口可为对象进行自定义排序规则。 使用方式 （1）实现Comparable接口，重写compareto()方法；接口中通过x.compareTo(y)来比较x和y的大小。若返回负数，意味着x比y小；返回零，意味着x等于y；返回正数，意味着x大于y。 /** * 方法一：实现Comparable接口，重写compareto()方法 */ class Person implements Comparable<Person>{ priva
Comparable接口和Comparator接口的区别
hsdmw123的博客
10-15 461
简单记录java中Comparable和Comparator的一些区别和特点。
Comparable接口与Comparator的使用
m0_60318777的博客
12-06 647
一、说明： JAVA中的对象，正常情况下，只能进行比较：==或！=。不能使用>或<的 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。 如何实现?使用两个接口中的任何一个: Comparable或Comparator 二、Comparable接口与Comparator的使用的对比: Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小 Comparator接口属于临...
浅析Java中comparator接口与Comparable接口的区别
09-01
在Java编程语言中，Comparable和Comparator接口都用于比较对象，但它们之间存在一些关键区别，这对于理解和优化代码的可扩展性至关重要。 首先，Comparable接口是一个排序接口，它定义了一个单一的方法`compareTo(T...
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接口的区别
07-13
comparator接口与Comparable接口的区别
关于comparator接口和comparable接口以及它们各自的方法compare()和compareTo()
HIT_微笑前进的专栏
03-16 7540
在今天做的LeetCode的题中有两道都出现了利用接口实现对象的排序，两题的相关链接： 1.利用comparable接口对对象排序 2.利用comparator接口实现排序 由于之前都没接触过这两个接口，一时不能明白它们的作用，所以在网上查找了很多资料，现在大致弄清楚一些，现在记录下来，有什么欠缺，欢迎大家及时指正 1.Comparable接口 在java API文档中描述此接口
java Comparator接口中返回值 1，-1，0的理解
Beat_IT的博客
07-11 7082
java comparator 升序、降序、倒序从源码角度理解
Comparable接口和Comparator接口区别
hbjae28666的专栏
08-25 617
简单写下两种排序方法：  Comparable接口和Comparator接口，两个都是用来实现集合中元素的比较、排序的，只是两个接口使用的方式有些区别：  (1)、Comparable位于java.lang下。       接口中的方法有：   int   compareTo(Object obj)       Comparator位于java.util下       接口中的方法有两个
Comparator一知半解？那不妨来一起探个究竟
cb_code的博客
12-29 147
Comparator一知半解？那不妨来一起探个究竟 在java中，通常会对集合中的内容进行排序，这种排序可以理解为就是8大排序算法的用武之地，但奈何需求进度压迫，完成任务优先，先CV下，后续再优化；大部分人都是这么想的，当然java社区的大神也想到了，还给出了解决方案； 既 java.util.List#sort 该方法定义了一个排序，需要传入一个比较器java.util.Comparator，这样就可以快速的实现排序； 问题来了： 返回值是什么意思？ 我怎么决定增序还是降序？ 返回的-1，1，0 分别代
Java 两个比较器 Comparable 和 Comparator 的区别
Geffin的博客
11-26 495
1 前言 在我们自定义的数据结构需要排序时，需要一定的排序规则，这就需要用到今天我们介绍的两个比较器 Comparable 和 Comparator。 2 Comparable Comparable 位于 java.lang 包下，本质上是一个内比较器，实现了 Comparable 的类可以自己比较，至于比较的结果如何则需要依赖于自然比较方法 compareTo 的实现。 compareTo 的返...
Comparable和Comparator接口的使用
qq_35930102的博客
06-19 212
1 Comparable接口的说明 Integer，Character，String，Date都实现了Comparable接口 Integer按照数字大小排序； Character按照字符对应的asci码进行排序； String先按照子母排序，在按照长度排序； Date按照时间先后排序 2利用Comparable进行数组排序 public <T extends Comparable<T>> void sortArrays(T[] ts) { ..
Comparable和Comparator的用法
给我一根筷子，我能撬动整个地球
05-29 879
Java 中基本类型的比较可以使用比较运算符，不同于C++，Java 中的对象比较是不能利用运算符重载（尽管 Java 中有运算符重载现象）。Comparable 和 Comparator 接口的存在就是为了对象比较，我们可以在接口中定义对象比较规则，还可以利用 Collections.sort 和 Arrays.sort 方法对对象数组和集合进行排序。 Comparable接口 Comparator接口 ...
comparable接口和comparator
最新发布
03-16
"Comparable" 接口和 "Comparator" 接口都是用于排序的接口，但它们在实现方式和作用上略有不同。 "Comparable" 接口是 Java 中的一个内置接口，用于实现对象的自然排序。如果一个类实现了 "Comparable" 接口，那么...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值