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());