comparable 订阅
comparable是一个英语单词,形容词,作形容词时意为“类似的,可比较的;同等的,相当的”。 展开全文
comparable是一个英语单词,形容词,作形容词时意为“类似的,可比较的;同等的,相当的”。
信息
外文名
comparable
词    性
形容词
comparable单词发音
英[ˈkɒmpərəbl]美[ˈkɑːmpərəbl] [1] 
收起全文
精华内容
参与话题
问答
  • Comparable

    万次阅读 2019-02-24 22:11:08
    Comparable接口 1:所有可以 “排序” 的类都实现了java.lang.Comparable接口,Comparable接口中只有一个方法。 2:public int compareTo(Object obj) ; 该方法: 返回 0 表示 this == obj 返回整数表示 this &...
    Comparable接口

    1:所有可以 “排序” 的类都实现了java.lang.Comparable接口,Comparable接口中只有一个方法。
    2:public int compareTo(Object obj) ;
    该方法:
    返回 0 表示 this == obj
    返回整数表示 this > obj
    返回负数表示 this < obj
    3:实现了 Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。

    展开全文
  • Comparable与Comparator浅析

    万次阅读 多人点赞 2016-03-15 19:56:41
      今天博主在翻阅TreeMap的源码,发现其键必须是实现Comparable或者Comparator的接口时产生了一些兴趣,比如在TreeMap中的put方法分别对Comparable和Comparator接口分别进行处理。那么疑问就来了,Comparable和...

    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    欢迎跳转到本文的原文链接:https://honeypps.com/java/comparable-and-comparator-analysis/

      今天博主在翻阅TreeMap的源码,发现其键必须是实现Comparable或者Comparator的接口时产生了一些兴趣,比如在TreeMap中的put方法分别对Comparable和Comparator接口分别进行处理。那么疑问就来了,Comparable和Comparator接口的区别是什么,Java中为什么会存在两个类似的接口?

      Comparable和Comparator接口都是用来比较大小的,首先来看一下Comparable的定义:

     package java.lang;
    import java.util.*;
    public interface Comparable<T> {
        public int compareTo(T o);
    }
    

      Comparator的定义如下:

    package java.util;
    public interface Comparator<T> {
        int compare(T o1, T o2);
        boolean equals(Object obj);
    }
    

      Comparable对实现它的每个类的对象进行整体排序。这个接口需要类本身去实现(这句话没看懂?没关系,接下来看个例子就明白了)。若一个类实现了Comparable 接口,实现 Comparable 接口的类的对象的 List 列表 ( 或数组)可以通过 Collections.sort(或 Arrays.sort)进行排序。此外,实现 Comparable 接口的类的对象 可以用作 “有序映射 ( 如 TreeMap)” 中的键或 “有序集合 (TreeSet)” 中的元素,而不需要指定比较器。
      举例(类Person1实现了Comparable接口)

    package collections;
    
    public class Person1 implements Comparable<Person1>
    {
        private int age;
        private String name;
    
        public Person1(String name, int age)
        {
            this.name = name;
            this.age = age;
        }
        @Override
        public int compareTo(Person1 o)
        {
            return this.age-o.age;
        }
        @Override 
        public String toString()
        {
            return name+":"+age;
        }
    }
    

      可以看到Person1实现了Comparable接口中的compareTo方法。实现Comparable接口必须修改自身的类,即在自身类中实现接口中相应的方法。
      测试代码:

    		Person1 person1 = new Person1("zzh",18);
            Person1 person2 = new Person1("jj",17);
            Person1 person3 = new Person1("qq",19);
    
            List<Person1> list = new ArrayList<>();
            list.add(person1);
            list.add(person2);
            list.add(person3);
    
            System.out.println(list);
            Collections.sort(list);
            System.out.println(list);
    

      输出结果:

    [zzh:18, jj:17, qq:19]
    [jj:17, zzh:18, qq:19]
    

      如果我们的这个类无法修改,譬如String,我们又要对其进行排序,当然String中已经实现了Comparable接口,如果单纯的用String举例就不太形象。对类自身无法修改这就用到了Comparator这个接口(策略模式)。

    public final class Person2
    {
        private int age;
        private String name;
    
        public Person2(String name, int age)
        {
            this.name = name;
            this.age = age;
        }
    
        @Override 
        public String toString()
        {
            return name+":"+age;
        }
    
        //getter and setter方法省略....
    }
    

      如类Person2,这个类已经固定,无法进行对其类自身的修改,也修饰词final了,你也别想继承再implements Comparable,那么此时怎么办呢?在类的外部使用Comparator的接口。如下测试代码:

    		Person2 p1 = new Person2("zzh",18);
            Person2 p2 = new Person2("jj",17);
            Person2 p3 = new Person2("qq",19);
            List<Person2> list2 = new ArrayList<Person2>();
            list2.add(p1);
            list2.add(p2);
            list2.add(p3);
            System.out.println(list2);
            Collections.sort(list2,new Comparator<Person2>(){
    
                @Override
                public int compare(Person2 o1, Person2 o2)
                {
    	            if(o1 == null || o2 == null)
    					return 0;
                    return o1.getAge()-o2.getAge();
                }
    
            });
            System.out.println(list2);
    

      输出结果:

    [zzh:18, jj:17, qq:19]
    [jj:17, zzh:18, qq:19] 
    

      这里(public static <T> void sort(List<T> list, Comparator<? super T> c) )采用了内部类的实现方式,实现compare方法,对类Person2的list进行排序。
      再譬如博主遇到的真实案例中,需要对String进行排序,且不区分大小写,我们知道String中的排序是字典排序,譬如:A a D排序之后为A D a,这样显然不对,那么该怎么办呢?同上(下面代码中的list是一个String的List集合):

            Collections.sort(list, new Comparator<String>()
            {
                @Override
                public int compare(String o1, String o2)
                {
    	            if(o1 == null || o2 == null)
    					return 0;
                    return o1.toUpperCase().compareTo(o2.toUpperCase());
                }
            });
    

      这样就可以实现不区分大小进行排序String的集合了,是不是很方便~


      细心的同学可能会有疑问,明明在Comparator接口中定义了两个方法,为什么继承的时候只实现了一个方法,难道要颠覆我对Java接口常识的理解了嚒?
      实际上,我们知道当一个类没有显式继承父类的时候,会有一个默认的父类,即java.lang.Object,在Object类中有一个方法即为equals方法,所以这里并不强制要求实现Comparator接口的类要实现equals方法,直接调用父类的即可,虽然你显式的实现了equals()方法 will be a better choice~


      在《Effective Java》一书中,作者Joshua Bloch推荐大家在编写自定义类的时候尽可能的考虑实现一下Comparable接口,一旦实现了Comparable接口,它就可以跟许多泛型算法以及依赖于改接口的集合实现进行协作。你付出很小的努力就可以获得非常强大的功能。
      事实上,Java平台类库中的所有值类都实现了Comparable接口。如果你正在编写一个值类,它具有非常明显的内在排序关系,比如按字母顺序、按数值顺序或者按年代顺序,那你就应该坚决考虑实现这个接口。
      compareTo方法不但允许进行简单的等同性进行比较,而且语序执行顺序比较,除此之外,它与Object的equals方法具有相似的特征,它还是一个泛型。类实现了Comparable接口,就表明它的实例具有内在的排序关系,为实现Comparable接口的对象数组进行排序就这么简单: Arrays.sort(a);
      对存储在集合中的Comparable对象进行搜索、计算极限值以及自动维护也同样简单。列如,下面的程序依赖于String实现了Comparable接口,它去掉了命令行参数列表中的重复参数,并按字母顺序打印出来:

    public class WordList{
        public static void main(String args[]){
            Set<String> s = new TreeSet<String>();
            Collections.addAll(s,args);
            System.out.println(s);
        }
    }
    

      Comparable 是排序接口;若一个类实现了 Comparable 接口,就意味着 “该类支持排序”。而 Comparator 是比较器;我们若需要控制某个类的次序,可以建立一个 “该类的比较器” 来进行排序。
      前者应该比较固定,和一个具体类相绑定,而后者比较灵活,它可以被用于各个需要比较功能的类使用。可以说前者属于 “静态绑定”,而后者可以 “动态绑定”。
      我们不难发现:Comparable 相当于 “内部比较器”,而 Comparator 相当于 “外部比较器”。

    欢迎跳转到本文的原文链接:https://honeypps.com/java/comparable-and-comparator-analysis/


    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    展开全文
  • Comparable排序

    2019-04-26 22:18:06
    Comparable排序 开发工具与关键技术:MyEclipse,Java 作者:吴耀存 撰写时间:2019-04-27 总结Comparable排序的步骤: 1.封装类,把一些需要排序的字段给封装起来,提高安全性 2.实现接口Comparable<>排序接口...

    Comparable排序

    开发工具与关键技术:MyEclipse,Java
    作者:吴耀存
    撰写时间:2019-04-27
    总结Comparable排序的步骤:
    1.封装类,把一些需要排序的字段给封装起来,提高安全性
    2.实现接口Comparable<>排序接口,在Comparable接口的<>里面写入实现类(当前类)
    3.实现Comparable的抽象方法,方法体写的是怎么个排序法。
    4.创建构造器,构造器带有需要排序的字段,作用是:集合添加数据时必须按照的构造器的参数个数类型来添加。
    5.创建集合,集合的类型是实现类
    6.集合添加数据,添加是要new 构造器 在加上参数
    7. 调用Collections.sort(集合)进行排序。
    8.使用迭代器看下排序效果,完成
    定义排序方法:
    1.先按照年龄来排序
    2.在对名称排序,名称是字符串,而字符串是Unicode编码来排序的
    3.最后在对bijiaoa排序
    在这里插入图片描述
    这是另一个类,我要调用实现了Comparable接口的实现类来帮我对集合排序
    在这里插入图片描述
    排序结果图:
    在这里插入图片描述

    展开全文
  • Comparable接口

    2020-04-27 13:54:25
    Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持 排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或 Arrays.sort进行自动排序。 此外,实现此接口的对象可以...

     

        Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持 排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或 Arrays.sort进行自动排序。

        此外,实现此接口的对象可以用作有序映射中的键或有序集合中的集合,无需指 定比较器。

        此接口只有一个方法compare,比较此对象与指定对象的顺序,如果该对象小 于、等于或大于指定对象,则分别返回负整数、零或正整数。

    public class ListComparableDemo {

           public static void main(String[] args) {

                  List<PersonComparable> persons = new ArrayList<PersonComparable>();

       

             persons.add(new PersonComparable("A",35));

             persons.add(new PersonComparable("B",25));

             persons.add(new PersonComparable("C",25));

             persons.add(new PersonComparable("D",15));

             persons.add(new PersonComparable("X",45));

             persons.add(new PersonComparable("M",35));

             persons.add(new PersonComparable("E",21));

     

             //排序的方法

             //第三步 调用sort排序

             Collections.sort(persons);

             //for循环

             for (PersonComparable person : persons) {

                 System.out.println(person.getName()+" "+person.getAge());

             }

     

             //System.out.println(persons);

        }

     

    }

     

     

    //第一步 :实现接口Comparable<T>

    class PersonComparable implements Comparable<PersonComparable>{

        private String name;

        private int age;

       

        //构造器

        public PersonComparable() {

             super();

        }

        //构造器

        public PersonComparable(String name, int age) {

             super();

             this.name = name;

             this.age = age;

        }

        public String getName(){

             return name;

        }

       

        public void setName(String name){

             this.name = name;

        }

        public int getAge(){

             return age;

        }

        public void setAge(int age){

             this.age = age;

        }

        /**

        * 第二步 实现compareTo方法 o 表示和当前对象比较的另外一个对象

        */

        @Override

        public int compareTo(PersonComparable o) {

             //从小到大:this-o

             //从大到小:o-this

             //return this.age-o.age;

             if(this.age!=o.age){

                 return this.age-o.age;

             }else{

                 return this.name.compareTo(o.name);

             }

        }

    }

    展开全文
  • * /* DDC:severe: StaticTypeError, Type check failed: Comparable.compare ((Comparable<dynamic>, Comparable<dynamic>) → int) is not of type (T, T) → int */ Comparable.compare); ...
  • Comparable用法

    2019-08-12 17:12:44
    Comparable用法 1、如果在类内部重写compareTo方法则需先继承Comparable。 2、compareTo重写后可自定义对象的对比属性,然后使用Arrays.sort方法排序。
  • Comparable 排序

    2019-09-25 08:31:22
    在jdk5时Comparable改成了Comparable 功能:用于对象的排序或者对象的分组 介绍:Comparable接口强行对实现它的类的每个实例进行自然排序,该接口的唯一方法compareTo方法被称为自然比较方法;强烈建议自然排序和...
  • Comparable 接口

    2019-09-28 11:01:11
    Comparable 接口 转载于:https://www.cnblogs.com/hglibin/p/11385919.html
  • Comparable和Comparator

    2020-01-07 16:56:44
    一、Comparable简介  Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。  调用...
  • Comparable VS Comparator

    2021-01-07 23:05:20
    Java 中的排序是由 Comparable 和 Comparator 这两个接口来实现的。 Comparable表示可被排序的,实现该接口的类的对象自动拥有排序功能,属于内部顺序,但需要手动实现接口,侵入性比较强。 Comparator则表示一个...
  • Comparable与Comparator

    2020-08-09 10:48:41
    Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。 package java.lang; import java....
  • comparator和comparable

    2020-05-17 23:02:28
    Comparable是排序接口,若一个类实现了Comparable接口,就意味着“该类支持排序”。而Comparator是比较器,我们若需要控制某个类的次序,可以建立一个“该类的比较器”来进行排序。  Comparable相当于“内部比较器...

空空如也

1 2 3 4 5 ... 20
收藏数 17,890
精华内容 7,156
关键字:

comparable