Java-Comparable和Comparator的区别

发表于 | 分类于

Comparable

Comparable接口是排序接口，实现了这个借口的数据类型或者类可以通过Collection.sort()和Arrays.sort()自动排序，此接口中有一个方法compareTo().

public int compareTo(T p);

Comparable是内部比较器，需要在一个类的内部实现,在类中需要重写compareTo方法，在此方法中需要实现所要比较的方式，比如如下代码，比较两个对象的方式是先比较姓名，如果一样在比较年龄。

定义一个实现了Comparable接口的Person类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Person implements Comparable<Person> {
	private String name;
	private int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	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 int compareTo(Person p){
		int rest=this.name.compareTo(p.name);
		if(rest!=0){
			return rest;
		}else{
			return this.age-p.age;
		}
	}
}

测试Person类的排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class test {
	public static void main(String[] args){
		Person p1=new Person("keluosi",27);
		Person p2=new Person("nuoyier",30);
		Person p3=new Person("luoyisi",26);
		System.out.println(p1.compareTo(p2));
		Person[] people=new Person[]{p1,p2,p3};
		System.out.println("before sort:");
		for(Person p:people){
			System.out.println(p.getName()+"---"+p.getAge());
		}
		Arrays.sort(people);
		System.out.println("after sort:");
		for(Person p:people){
			System.out.println(p.getName()+"---"+p.getAge());
		}
	}
}

Comparator

Comparator是比较接口，如果一个类没有实现Comparable接口需要对该类排序，则可以设计一个实现Comparator接口的比较器，通过这个类的比较器就可以对该类排序。
Comparator是外部比较器，和Comparale不同不需要在类中实现，在对一个类实现比较排序时可以不用修改该类的源代码，只需创建该类的比较器利用这个比较器就可以对该类进行排序。使用Comparator有两种方式：一种是创建实现Compartor接口的比较器，使用时直接创建该比较器的对象；另一种是直接在使用到比较器的地方创建一个匿名内部类。
如下代码：
实现了Person类的比较器：

1
2
3
4
5
6
public class PersonComparator implements Comparator<Person> {
	public int compare(Person p1,Person p2){
		int rest=p1.getName().compareTo(p2.getName());
		return rest!=0 ? rest:p1.getAge()-p2.getAge();
	}
}

使用测试：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class test {
	public static void main(String[] args){
		Person p1=new Person("keluosi",27);
		Person p2=new Person("nuoyier",30);
		Person p3=new Person("luoyisi",26);
		System.out.println(p1.compareTo(p2));
		Person[] people=new Person[]{p1,p2,p3};
		System.out.println("before sort:");
		for(Person p:people){
			System.out.println(p.getName()+"---"+p.getAge());
		}
		//使用比较器，创建比较器的对象
		PersonComparator pc=new PersonComparator();
		Arrays.sort(people,pc);
		//创建匿名内部类，直接在使用Comparator的地方创建一个Comparator对象并重写compare方法
		Arrays.sort(people,new Comparator<Person>(){
			public int compare(Person p1,Person p2){
				return p1.getAge()-p2.getAge();
			}
		});
		System.out.println("after sort:");
		for(Person p:people){
			System.out.println(p.getName()+"---"+p.getAge());
		}
	}
}

对比：Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。

Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

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