Comparable＜T＞ 和 Comparator＜T＞ 的区别

Comparable

package java.lang;
import java.util.*;
public interface Comparable<T> {
//函数式接口
    public int compareTo(T o);
}

 

首先它是在java.lang包下的

有一个 返回值为 int型的 抽象方法

compareTo(T o)

传入参数是一个泛型 在定义这个接口的时候可以传入类型

参数 o与自己比较的对象

实例

package com.mc.demo.compare;
//让这个类实现 Comparable 接口
public class User implements Comparable<User> {
    //用户姓名
    private String name;
    //年龄
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public int compareTo(User user1) {
        //如果自身年龄 大于 user1的年龄 输出大于0 等于输出0 小于输出负数
        return this.getAge() - user1.getAge();
    }

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

package com.mc.demo.compare;

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

public class ComparableTest {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setAge(3);
        user1.setName("mc");
        User user2 = new User();
        user2.setAge(5);
        user2.setName("lmf");
        List<User> list = new ArrayList<>();
        list.add(user2);
        list.add(user1);
        System.out.println("排序前....");
        for(User u:list) {
            System.out.println(u);
        }
        Collections.sort(list);
        System.out.println("排序后....");
        for(User u:list){
            System.out.println(u);
        }
    }
}

运行结果

排序前....
User{name='lmf', age=5}
User{name='mc', age=3}
排序后....
User{name='mc', age=3}
User{name='lmf', age=5}

Comparator<T>

package java.util;

@FunctionalInterface
public interface Comparator<T> {


    //也是一个函数式接口
    int compare(T o1, T o2);

}

这个方法的作用是比较两个参数的顺序。返回负整数，零或正整数，因为第一个参数小于或等于或大于第二个参数。

参数 o1 -要比较的第一个元素 o2 要比较的第二个元素

1.首先comparator 在java.util包下

2.他也有一个抽象方法，不过需要传递两个对象

实例

package com.mc.demo.compare;
//让这个类实现 Comparable 接口
//public class User implements Comparable<User> {
public class User{
    //用户姓名
    private String name;
    //年龄
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

//    @Override
//    public int compareTo(User user1) {
//        //如果自身年龄 大于 user1的年龄 输出大于0 等于输出0 小于输出负数
//        return this.getAge() - user1.getAge();
//    }

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

package com.mc.demo.compare;

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorTest {
    public static void main(String[] args) {
        //使用lambad表达式实现一个Comparator的接口
        Comparator<User> comparator = (o1,o2)->{
            return o1.getAge()-o2.getAge();
        };
        User[] users = new User[2];
        User user1 = new User();
        user1.setAge(3);
        user1.setName("mc");
        User user2 = new User();
        user2.setAge(5);
        users[0] = user2;
        users[1] = user1;
        //排序前
        for(User u:users){
            System.out.println(u);
        }
        //排序后
        Arrays.sort(users,comparator);
        System.out.println("排序后..............");
        for(User u:users){
            System.out.println(u);
        }
    }
}

总结

1.首先Comparable 在java.lang包下，Comparator 在java.util包下

2.Comparable中的比较方法需要传递一个参数，而Comparator需要传递两个参数

3.如果一个类实现类Comparable接口，就意味着这个类支持排序。而Comparator相当于一个比较器，我们如果需要控制某个类的次序，可以建立一个该类的比较器来进行排序

4.两种方法各有优劣， 用Comparable 简单， 只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。