Comparable 与 Comparator

1.背景

最近一些业务需求总是遇到用List<对象>的比较,下面介绍下用到的排序的两种方法Comparable 与 Comparator。

2.定义

Comparable和Comparator都是用来实现集合中元素的比较、排序的。
Comparable是在集合内部定义的方法实现的排序,位于java.lang下。
Comparator是在集合外部实现的排序,位于java.util下。

2.1.Comparable

Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了Comparable接口的类如何比较,则依赖compareTo方法的实现,compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话,那么这个对象必须实现Comparable接口。compareTo方法的返回值是int,有三种情况:

1、比较者大于被比较者(也就是compareTo方法里面的对象),那么返回正整数
2、比较者等于被比较者,那么返回0
3、比较者小于被比较者,那么返回负整数

2.2.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小于o2,返回负整数

3.示例

3.1.Comparable

Comparable会对实现它的每个类的对象进行整体排序。这个接口需要类本身去实现。若一个类实现了Comparable 接口,实现 Comparable 接口的类的对象的 List 列表 ( 或数组)可以通过 Collections.sort(或 Arrays.sort)进行排序。此外,实现 Comparable 接口的类的对象 可以用作 “有序映射 ( 如 TreeMap)” 中的键或 “有序集合 (TreeSet)” 中的元素,而不需要指定比较器。

定义实现User类,实现Comparable

package com.test.one;

/**
 * 描述:
 * 作者:袁伟倩
 * 创建日期:2017-10-14 16:04.
 */

public class User implements Comparable<User> {

    // 年龄
    private int age;
    // 姓名
    private String name;

    // 创建有参构造方法
    public User(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // get/set方法
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    // 生成tostring方法
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    // 重写comparable的方法
    @Override
    public int compareTo(User o) {
        int i = this.age-o.age;
        return i;
    }
}

定义Test类,运行效果

package com.test.one;

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

/**
 * 描述:
 * 作者:袁伟倩
 * 创建日期:2017-10-14 15:36.
 */

public class Test {

    public static void main(String[] args) {

        User user1 = new User("张三",18);
        User user2 = new User("李四",17);
        User user3 = new User("赵五",19);

        List<User> list = new ArrayList<User>();

        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }

}

运行结果

[User{age=18, name='张三'}, User{age=17, name='李四'}, User{age=19, name='赵五'}]
[User{age=17, name='李四'}, User{age=18, name='张三'}, User{age=19, name='赵五'}]

分析运行效果
这里写图片描述

一开始创建对象user1,对象实例o 是张三,当运行到user2时,this就是对象user2,此时会进行排序,这个时候返回到i是 -1,即对象user2中到age比对象user1到小。

继续运行程序
这里写图片描述
当前运行到this对象是user3,对象o是上一步到对象user2,此时i返回为2,即age在对象user2比对象user3小;

之后在运行 Collections.sort(list); 其底层是

  default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

Arrays.sort是正序。所以最终结果是递增的。

总结:User类实现了Comparable接口中的compareTo方法。实现Comparable接口必须修改自身的类,即在自身类中实现接口中相应的方法。

3.2.Comparator

上面介绍了通过类实现Comparable接口,可以实现排序,那么对于这个类已经固定,无法进行对其类自身的修改,也修饰词final了,你也别想继承再implements Comparable,那么此时怎么办呢?在类的外部使用Comparator的接口。

对象类

package com.test.one;

/**
 * 描述:
 * 作者:袁伟倩
 * 创建日期:2017-10-14 17:11.
 */

public class Person {
    // 年龄
    private int age;
    // 姓名
    private String name;

    // 创建有参构造方法
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // get/set方法
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    // 生成tostring方法
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

}

实现

package com.test.one;

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

/**
 * 描述:
 * 作者:袁伟倩
 * 创建日期:2017-10-14 17:12.
 */

public class TestPerson {
    public static void main(String[] args) {

        Person user1 = new Person("张三",18);
        Person user2 = new Person("李四",17);
        Person user3 = new Person("赵五",19);

        List<Person> list = new ArrayList<Person>();

        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println(list);
        Collections.sort(list,new Comparator<Person>(){

            @Override
            public int compare(Person o1, Person o2)
            {
                if(o1 == null || o2 == null) return 0;

                return o1.getAge()-o2.getAge();
            }

        });
        System.out.println(list);
    }
}

这里(public static void sort(List list, Comparator<? super T> c) )采用了内部类的实现方式,实现compare方法,对类Person的list进行排序。

4.综述

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

5、java8以上的Lambda比较器

在java8以上版本,List接口直接提供了排序方法, 所以不需要使用Collections.sort。


//循环
listDevs.forEach((developer)->System.out.println(developer));
//排序
listDevs.sort((Developer o1, Developer o2)->o1.getAge()-o2.getAge());
//根据名字排序
listDevs.sort((o1, o2)->o1.getName().compareTo(o2.getName()));
//从小到大
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
    listDevs.sort(salaryComparator);
//从大到小 
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator.reversed());

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值