Comparable和Comparator都是用来实现集合中的排序的,Comparator位于包java.util下,而Comparable位于包java.lang下,Comparable是一个对象本身就已经支持自比较所需要实现的接口(如 String、Integer 自己就可以完成比较大小操作),是内部定义的排序;而后者在一个独立的类中实现比较,是外部实现的排序。 如果一个类没有实现Comparable接口,或是这个对象不支持自比较或者自比较函数不能满足你的要求时,可以通过Comparator来实现比较算法进行排序,并且为了使用不同的排序标准做准备,比如:升序、降序。所以,如想实现排序,就需要让类对象自身实现Comparable接口,重写其中的compareTo(T o)方法;或在外部定义比较器实现Comparator接口,重写其compare(T o1,T o2)方法。前者只有一个参数,后者有两个参数。排序时可以调用java.util.Arrays.sort()来排序对象数组,或是调用集合中的sort()方法就可以按照相应的排序方法进行排序。方法返回一个基本类型的整型,返回负数表示o1小于o2,返回0表示o1和o2相等,返回正数表示o1大于o2。
用 Comparator 是策略模式(strategy design pattern),就是不改变对象自身,而用一个策略对象(strategy object)来改变它的行为。比如:你想对整数采用绝对值大小来排序,Integer 是不符合要求的,你不需要去修改 Integer 类(实际上你也不能这么做)去改变它的排序行为,只要使用一个实现了Comparator接口的对象来实现控制它的排序就行了。
Comparable
public interface Comparable<T>
1.Comparable接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ,类的compareTo方法被称为其自然比较方法。该接口有且只有一个方法int compareTo(T o)所以继承此接口需要实现该方法。compareTo返回值-1、0、1。
2.Collections.sort (和Arrays.sort )可以自动对实现此接口的对象进行列表(和数组)排序。 实现该接口的对象,可以使用如在键sorted map或作为在元件sorted set ,而不需要指定一个comparator 。
Comparator
public interface Comparator<T>
1.比较功能,对一些对象的集合施加了一个整体排序 。 可以将比较器传递给排序方法(如Collections.sort或Arrays.sort ),以便对排序顺序进行精确控制。 比较器还可以用来控制某些数据结构(如顺序sorted sets或sorted maps ),或对于不具有对象的集合提供的排序natural ordering 。
2.通过比较c上的一组元素S的确定的顺序对被认为是与equals一致当且仅当c.compare(e1, e2)==0具有用于S每e1和e2相同布尔值e1.equals(e2)。
3.一般是在比较器例如: Collections.sort(List<T> list, Comparator<? super T> c) ,Arrays.sort(T[] a, Comparator<? super T> c)根据指定的比较器引起的顺序对指定的列表进行排序。 在Comparator比较器中重写int compare(T o1, T o2) 如果遇到数字的比较,直接在方法内返回两个对象的属性的差值,例如o1.getValue()-o2.getValue() 是升序,o2.getValue()-o1.getValue() 是降序;如果遇到字符形式的比较利用compareTo(T o)
例子:
1. import java.util.Arrays;
2. import java.util.Comparator;
3. class Person implements Comparable<Person>{
4. private String name;
5. private int age;
6. public Person(String name, int age) {
7. this.name = name;
8. this.age = age;
9. }
10. public String getName() {
11. return this.name;
12. }
13. public int getAge() {
14. return this.age;
15. }
16. @Override
17. public String toString() {
18. return ""+this.name+" "+this.age;
19. }
20. @Override
21. public int compareTo(Person o) {
22. //返回值是负数,就是降序排序
23. if (this.getName().compareTo(o.getName()) != 0)
24. return this.getName().compareTo(o.getName());
25. else {
26. if (this.getAge() < o.getAge())
27. return -1;
28. else if (this.getAge() > o.getAge())
29. return 1;
30. else return 0;
31. }
32. }
33. }
34. class Cmp implements Comparator {
35. @Override
36. public int compare(Object arg0, Object arg1) {
37. Person a = (Person) arg0;
38. Person b = (Person) arg1;
39. if (a.getName().compareTo(b.getName()) != 0)
40. return a.getName().compareTo(b.getName());
41. else {
42. if (a.getAge() < b.getAge())
43. return -1;
44. else if (a.getAge() > b.getAge())
45. return 1;
46. else return 0;
47. }
48. }
49. }
50. public class Main {
51. public static void main(String[] args) {
52. new Person[4];
53. 0] = new Person("ZZZ",19);
54. 1] = new Person("AAA", 109);
55. 2] = new Person("AAA", 19);
56. 3] = new Person("YYY",100);
57. // Arrays.sort(p);//调用自有的排序
58. new Cmp());//调用Comparator定义的排序
59. System.out.println(Arrays.toString(p));
60. }
61. }
import java.util.*;
import java.lang.Comparable;
/**
* @desc "Comparator"和“Comparable”的比较程序。
* (01) "Comparable"
* 它是一个排序接口,只包含一个函数compareTo()。
* 一个类实现了Comparable接口,就意味着“该类本身支持排序”,它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。
* (02) "Comparator"
* 它是一个比较器接口,包括两个函数:compare() 和 equals()。
* 一个类实现了Comparator接口,那么它就是一个“比较器”。其它的类,可以根据该比较器去排序。
*
* 综上所述:Comparable是内部比较器,而Comparator是外部比较器。
* 一个类本身实现了Comparable比较器,就意味着它本身支持排序;若它本身没实现Comparable,也可以通过外部比较器Comparator进行排序。
*/
public class CompareComparatorAndComparableTest{
public static void main(String[] args) {
// 新建ArrayList(动态数组)
ArrayList<Person> list = new ArrayList<Person>();
// 添加对象到ArrayList中
list.add(new Person("ccc", 20));
list.add(new Person("AAA", 30));
list.add(new Person("bbb", 10));
list.add(new Person("ddd", 40));
// 打印list的原始序列
System.out.printf("Original sort, list:%s\n", list);
// 对list进行排序
// 这里会根据“Person实现的Comparable<String>接口”进行排序,即会根据“name”进行排序
Collections.sort(list);
System.out.printf("Name sort, list:%s\n", list);
// 通过“比较器(AscAgeComparator)”,对list进行排序
// AscAgeComparator的排序方式是:根据“age”的升序排序
Collections.sort(list, new AscAgeComparator());
System.out.printf("Asc(age) sort, list:%s\n", list);
// 通过“比较器(DescAgeComparator)”,对list进行排序
// DescAgeComparator的排序方式是:根据“age”的降序排序
Collections.sort(list, new DescAgeComparator());
System.out.printf("Desc(age) sort, list:%s\n", list);
// 判断两个person是否相等
testEquals();
}
/**
* @desc 测试两个Person比较是否相等。
* 由于Person实现了equals()函数:若两person的age、name都相等,则认为这两个person相等。
* 所以,这里的p1和p2相等。
*
* TODO:若去掉Person中的equals()函数,则p1不等于p2
*/
private static void testEquals() {
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
if (p1.equals(p2)) {
System.out.printf("%s EQUAL %s\n", p1, p2);
} else {
System.out.printf("%s NOT EQUAL %s\n", p1, p2);
}
}
/**
* @desc Person类。
* Person实现了Comparable接口,这意味着Person本身支持排序
*/
private static class Person implements Comparable<Person>{
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String toString() {
return name + " - " +age;
}
/**
* 比较两个Person是否相等:若它们的name和age都相等,则认为它们相等
*/
boolean equals(Person person) {
if (this.age == person.age && this.name == person.name)
return true;
return false;
}
/**
* @desc 实现 “Comparable<String>” 的接口,即重写compareTo<T t>函数。
* 这里是通过“person的名字”进行比较的
*/
@Override
public int compareTo(Person person) {
return name.compareTo(person.name);
//return this.name - person.name;
}
}
/**
* @desc AscAgeComparator比较器
* 它是“Person的age的升序比较器”
*/
private static class AscAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}
/**
* @desc DescAgeComparator比较器
* 它是“Person的age的
降序比较器”
*/
private static class DescAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
}
}