Comparator和Comparable的区别以及Collections.sort排序原理

一、概述

Comparable和Comparator都是两个接口,接口都可以用来实现集合中元素的比较、排序,Comparator位于包java.util下,而Comparable位于包java.lang下,Comparable接口将比较代码嵌入自身类中,而Comparator既可以嵌入到自身类中,也可以在一个独立的类中实现比较。
  
Integer、String等这些基本类型的JAVA封装类都已经实现了Comparable接口,这些类对象本身就支持自比较,直接调用Collections.sort()就可以对集合中元素的排序,无需自己去实现Comparable接口。
而有些自定义类的List序列,当这个对象不支持自比较或者自比较函数不能满足你的要求时,你可以写一个比较器来完成两个对象之间大小的比较,也就是指定使用Comparator(临时规则排序,也称作专门规则排序),如果不指定Comparator,那么就用自然规则排序,这里的自然顺序就是实现Comparable接口设定的排序方式。

Comparator和Comparable的区别以及Collections.sort排序原理_第1张图片

二、Comparable

Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了Comparable接口的类如何比较,则依赖compareTo方法的实现,compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话,那么这个对象必须实现Comparable接口。
compareTo方法的返回值是int,有三种情况:
实际原理是重写 compareTo(Object obj) 方法的规则(两个对象通过该方法的返回值来比较大小):
如果当前对象this大于形参对象obj,则返回正整数;
如果当前对象this小于形参对象obj,则返回负整数;
如果当前对象this等于参数对象obj,则返回零。

三、Comparator

Comparator可以认为是是一个外比较器,个人认为有两种情况可以使用实现Comparator接口的方式:
1、一个对象不支持自己和自己比较(没有实现Comparable接口),但是又想对两个对象进行比较
2、一个对象实现了Comparable接口,但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法,方法有两个参数T o1和T o2,是泛型的表示方式,分别表示待比较的两个对象,方法返回值和Comparable接口一样是int,有三种情况:
1、o1大于o2,返回正整数
2、o1等于o2,返回0
3、o1小于o3,返回负整数

四 、compareTo(T o)和compare(T o1 T o2)的排序原理

举一个例子

public class TEST {
    public static void main(String[] args) throws IOException {
        Intnumber a = new Intnumber(5);
        Intnumber b = new Intnumber(35);
        Intnumber c = new Intnumber(7);
        Intnumber d = new Intnumber(3);
       List<Intnumber> list = new ArrayList<Intnumber>();
       list.add(a);
       list.add(b);
       list.add(c);
       list.add(d);
       Collections.sort(list);
      list.forEach(v->System.out.println(v.getNumber()));
    }
}

 class Intnumber implements Comparable<Intnumber>{
     public Intnumber(Integer number) {
         this.number = number;
     }

     public Integer getNumber() {
         return number;
     }

     public void setNumber(Integer number) {
         this.number = number;
     }

     Integer number;

     @Override
     public int compareTo(Intnumber o) {
//         return this.number-o.number;//升序
         //  if(this.number
         // --------------------------------------------------
//         return o.number-this.number;//降序
           if(this.number>o.number) return -1; else return 1; // 降序
     }
 }

结果:35
7
5
3

我们知道

倒序:
//直接
return -1;
不改变顺序:
//直接
return 0或者1;

= 0 或者 1效果是一样的位置不变;-1相同元素会发生位置调整
sort会按照返回的结果排序
compareTo(T o) 一般方法内是{this.xx或o.xxx}和compare(T o1 T o2)一般方法内是{o1.xx或o2.xxx}
新加入的元素会是(this.xx或o1.xxx)与之前插入元素(o.xx或o2.xxx)与进入方法内进行操作而不是方法内的位置关系
如果返回的结果是
1是新加入的元素(this.xx或o1.xxx)权重大,-1是之前插入的元素(o.xx或o2.xxx)大。
JAVA则按照权重由小到大排序。
这样说法也好理解:
如果新加入的元素(this.xx或o1.xxx)<之前插入元素(o.xx或o2.xxx),返回-1,则之前插入元素重大所以要与新加入的元素交换位置(交换位置与数值无关与权重有关),交换位置后发现,加入新加入的元素是5小于之前插入的元素7,原本应该是7,5由于权重原因交换了位置,现在为5,7 所以是升序排列
如果想要降序,则需要新加入的元素(this.xx或o1.xxx)<之前插入元素(o.xx或o2.xxx) 返回1,则新加入的元素(this.xx或o1.xxx)权重大,例如新加入是5 ,之前插入是7。则结果为7,5,降序。
这样写代码的时候,你只要考虑权重就能得到满足需求

我们执行代码会发现,到第二个参数35插入到排序时,他是以this.number 数字35 与 o.number 之前的插入的元素数字 5进入到方法内 。return this.number-o.number; 则35-5=30 这说明新加入的元素35(this.number)权重大,排在原来的插入的位置, 5,35,升序 。 如果是return o.number-this.number;则5-35=-30说明之前插入的元素5(o.number) 权重比较大,需要与35位置交换,由原理插入顺序5,35转为 35,5 所以为降序。 compara同理,把o1当作this,把o2当作o即可

五、Comparator和Comparable的区别

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用:
1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准,比如升序、降序等

总结一下,两种比较器Comparable和Comparator,后者相比前者有如下优点:
1、如果实现类没有实现Comparable接口,又想对两个类进行比较(或者实现类实现了Comparable接口,但是对compareTo方法内的比较算法不满意),那么可以实现Comparator接口,自定义一个比较器,写比较算法
2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些,如果要修改比较算法,则需要修改Comparable接口的实现类,而实现Comparator的类是在外部进行比较的,不需要对实现类有任何修改。从这个角度说,实现Comparable接口的方式其实有些不太好,尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator 接口的方式后面会写到就是一种典型的策略模式。

六、实现方式

下面我们看一下具体实现方式:

1、Comparable

首先来看一下Comparable接口,我们想要对一个类自身进行排序,那么我们可以让这个类实现Comparable接口,重写其中的compareTo方法完成:

package cn.lxx.test;
 
public class User implements Comparable<User> {   //该类实现Comparable接口,参数为User
    private String name;
    private int age;
    private boolean sex;
 
    public User() {
    }
 
    public User(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
 
    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;
    }
 
    public boolean isSex() {
        return sex;
    }
 
    public void setSex(boolean sex) {
        this.sex = sex;
    }
 
    /**
     * 重写compareTo方法,实现年龄升序,年龄相同则姓名升序
     **/
    @Override
    public int compareTo(User user) {
        if (this.age == user.age) return this.name.compareTo(user.name);
        return this.age - user.age; //将this想像成要插入的对象,而User就是之前存在的对象,只有this属性大于user属性返回权重正数,说明新加入的参数权重大,不改变位置而升序,个人理解,希望有所帮助
    }
}
 
class Test {
    public static void main(String[] args) {
        User user1 = new User("ake", 25, true);
        User user2 = new User("reo", 24, false);
        User user3 = new User("fg", 24, false);
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        Collections.sort(list);
        System.out.println("Comparable:" + list);
    }
}

结果:
Comparable:[User{name=‘fg’, age=24, sex=false}, User{name=‘reo’, age=24, sex=false}, User{name=‘ake’, age=25, sex=true}]

2、Comparator

在第二种实现方式Comparator接口中,总结了类自身实现Comparator接口重写compare方法的比较器、类外实现比较器和使用Lambda表达式简化比较器实现。

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

public class User implements Comparator<User> {
   private String name;
   private int age;
   private boolean sex;

   public User() {
   }

   public User(String name, int age, boolean sex) {
       this.name = name;
       this.age = age;
       this.sex = sex;
   }

   @Override
   public String toString() {
       return "User{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", sex=" + sex +
               '}';
   }

   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;
   }

   public boolean isSex() {
       return sex;
   }

   public void setSex(boolean sex) {
       this.sex = sex;
   }

   @Override
   public int compare(User o1, User o2) {
       return o1.age-o2.age;
   }
}

class Test{
   public static void main(String[] args) {
       User user1=new User("dingli",25,true);
       User user2=new User("huxiaojuan",24,false);
       User user3=new User("xxx",24,false);
       List<User> list=new ArrayList<User>();
       list.add(user1);
       list.add(user2);
       list.add(user3);
       Collections.sort(list, new User()); //类实现了的Comparator能满足需求
       System.out.println("类自身实现Comparator:"+list);
       //现在我想要按照名字升序,显然类中实现的不能满足要求,于是可以在类外自己实现想要的比较器
       Collections.sort(list, new Comparator<User>() {
           @Override
           public int compare(User o1, User o2) {
               return o1.getName().compareTo(o2.getName()); //按照名字升序
           }
       });
       System.out.println("匿名内部类方式:"+list);
       //由于Comparator接口是一个函数式接口,因此根据jdk1.8新特性,我们可以采用Lambda表达式简化代码
       Collections.sort(list,(u1,u2)->{return u1.getName().compareTo(u2.getName());});
       System.out.println("Lambda表达式方式:"+list);
   }
}

类自身实现Comparator:[User{name=‘reo’, age=24, sex=false}, User{name=‘fg’, age=24, sex=false}, User{name=‘ake’, age=25, sex=true}]

匿名内部类方式:[User{name=‘ake’, age=25, sex=true}, User{name=‘fg’, age=24, sex=false}, User{name=‘reo’, age=24, sex=false}]

Lambda表达式方式:[User{name=‘ake’, age=25, sex=true}, User{name=‘fg’, age=24, sex=false}, User{name=‘reo’, age=24, sex=false}]

你可能感兴趣的:(java,算法,数据结构)