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学习

    2021-04-17 11:45:18
    Comparable 用于对象的字段排序 使用 实现 Comparable 接口 重写 compareTo 方法 编写排序工具 Comparable getMax(Comparable c1,Comparable c2) 调用排序工具方法 getMax(s1, s2) public class Student ...

    Comparable 用于对象的字段排序
    使用

    1. 实现 Comparable 接口
    2. 重写 compareTo 方法
    3. 编写排序工具 Comparable getMax(Comparable c1,Comparable c2)
    4. 调用排序工具方法 getMax(s1, s2)
    public class Student implements Comparable<Student> {
        private String username;
        private int age;
    
        public Student(String username, int age) {
            this.username = username;
            this.age = age;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public int compareTo(Student o) {
            return this.age - o.age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "username='" + username + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    class Test1{
    
        public static <T> Comparable<T> getMax(Comparable<T> c1,Comparable<T> c2){
            int result = c1.compareTo((T) c2);
    
            // 如果result<0 c1就是小于c2
            // 如果result>0 c1就是大于c2
            // 如果result=0 c1就是等于c2
            if (result>= 0 ){
                return c1;
            }else{
                return c2;
            }
        }
    
        public static void main(String[] args) {
            Student s1 = new Student("张三", 2);
            Student s2 = new Student("李四", 1);
            Comparable<Student> max = getMax(s1, s2);
            System.out.println(max);
        }
    }
    

    输出

    Student{username='张三', age=2}
    
    展开全文
  • 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接口

    2021-05-24 17:00:10
    Java提供了一个Comparable接口用来定义排序规则。 下面是Comparable接口的声明以及作用,可以看到它可以使继承他的类进行比较大小,只需要调用实现类的compareTo方法即可。 comparableTo用法如下: 实例: ...

    Java提供了一个Comparable接口用来定义排序规则。

    下面是Comparable接口的声明以及作用,可以看到它可以使继承他的类进行比较大小,只需要调用实现类的compareTo方法即可。

    comparableTo用法如下:

    实例:

     

    展开全文
  • comparable接口

    2020-11-09 21:54:54
    java中comparable接口 在定义好goods类后进入接口comparable后进入compareto接口,然后再主函数中Arrays. sort调用接口进行比较,根据自己所需去比较 package mazhengting; import java.util.Arrays; public class ...
  • Comparable排序

    2019-04-16 21:47:27
    Comparable排序 作者:邹爱红,撰写时间:2019年04月18日 Comparable是排序接口,原生的类的话就不能去改它,自己定义的就可以改的 实现类后面的<>根据什么来排序,一般都是根据自己定义的类来排序 写一个...
  • 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与Comparator

    2019-07-14 16:52:43
    Java中有两种比较方法:Comparable与Comparator,这里头具体有什么区别呢?下面来了解一下。 1.Comparable源码 jdk中Comparable的源码如下 public interface Comparable<T> { public int compareTo(T o); } ...
  • ComparatorAndComparable

    2015-11-03 19:37:49
    教你学会Comparator和Comparable
  • Comparable和Comparator

    2021-06-07 21:15:58
    Comparable和Comparator 开发工具与关键技术:MySQL 作者:黄毓洪 撰写时间:20201年06月7日 今天我们来认识认识一下Java 中的Comparable 和 Comparator, 首先是来自Comparable的简介 -.Comparable的简单介绍 ...
  • Comparable & Comparator

    2021-05-31 23:07:39
    java.lang.Comparable和java.util.Comparator是java提供的两个可以用来指导排序的接口。 Comparable Comparable的用法需要待排序的类直接实现Comparable接口,同时通过在类中进行方法定义x.compareTo(y)来比较大小...
  • Comparable接口使用

    千次阅读 2021-03-25 11:50:32
    Comparable接口使用 总有数据库数据不方便OrderBy的时候,这时想要给集合里的对象排序该咋办呢? 1、实体类实现Comparable接口,实现compareTo方法,定义排序规则。 2、Collections.sort() 排序集合
  • Comparable与Comparetor

    2021-04-23 11:54:55
    Comparable Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序: Collections.sort...
  • List<Integer> list = Arrays.asList(1, 4, 2, 6, ...// Comparator.naturalOrder()使用其的前提是对象需实现Comparable接口,会调用其compare list.sort(Comparator.naturalOrder()); System.out.println(list);
  • 1、首先新建第一个Student类/** * 排序测试 通过实现Comprable的compareTo方法进行排序 */public class Student implements Comparable&lt;Student&gt;{ private String name; private Integer age; //排序...
  • Comparable VS Comparator

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,155
精华内容 49,262
关键字:

comparable