0008_Comparable和Comparator接口

Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

Comparable例子：
public class e_008_Comparable {
public static void main(String[] args) {
List list = new ArrayList<Pig>();
list.add(new Pig("adc")) ;
list.add(new Pig("abd")) ;
list.add(new Pig("abc")) ;
Collections.sort(list);
System. out.println(list);
}
}

class Pig implements Comparable<Object>{
private String name ;

public String getName() {
return name ;
}
public void setName(String name) {
this.name = name;
}
public Pig(String name) {
this.name = name;
}
@Override
public int compareTo(Object o) {
Pig c = (Pig)o;
return this .name .compareTo(c.name);
}
@Override
public String toString() {
return "Pig[name=" +this.name+"]";
}
}

[align=left]程序运行结果为：[/align]
[align=left][Pig[name=abc], Pig[name=abd], Pig[name=adc]][/align]
[align=left]输出的结果已经是经过排序的数据了。

[/align]
Comparable是在对象内部重写比较的方法，从而达到排序的目的。 而 Comparator 是一个专用的比较器，当这个对象不支持自比较(比如int比较)或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

比如：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不需要去修改 Integer 类（实际上你也不能这么做）去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。

[align=left]例子：[/align]
[align=left]自定义比较器：[/align]

class MyComparable implements Comparator<Object> {

@Override
public int compare(Object o1, Object o2) {
int v1 = Math.abs(((Integer) o1).intValue());
int v2 = Math.abs(((Integer) o2).intValue());
return v1 > v2 ? 1 : (v1 == v2 ? 0 : -1);
}
}

测试：

public static void main(String[] args) {
Integer[] integers = new Integer[2];
integers[0] = -1000;
integers[1] = 999;
//用内部排序
Arrays. sort(integers);
System. out.println(integers[0]+"," +integers[1]);
//用自定义排序
Arrays. sort(integers, new MyComparable());
System. out.println(integers[0]+"," +integers[1]);
}

[align=left]打印的结果为：[/align]

[align=left]-1000,999[/align]

[align=left]999,-1000[/align]
[align=left]可见已经实现了内部的排序。[/align]

对于已经实现了comparable的实体类，用自定义比较器比较的例子：

public class e_008_Comparable {
public static void main(String[] args) {
List list = new ArrayList<Pig>();
list.add(new Pig("adc")) ;
list.add(new Pig("abd")) ;
list.add(new Pig("abc")) ;
Collections.sort(list);
System. out.println(list);
Collections.sort(list,new MyComparable());
System. out.println(list);
}
}

class Pig implements Comparable<Object> {
private String name ;

public String getName() {
return name ;
}

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

public Pig(String name) {
this.name = name;
}

@Override
public int compareTo(Object o) {
Pig c = (Pig) o;
return this .name .compareTo(c.name);
}

@Override
public String toString() {
return "Pig[name=" + this. name + "]" ;
}
}

class MyComparable implements Comparator<Pig>{

@Override
public int compare(Pig o1, Pig o2) {
String name1 = o1.getName();
String name2 = o2.getName();
return name1.compareTo(name2)>0?-1:(name1 == name2?0:1);
}
}

[align=left]
[/align]
[align=left]打印出的结果为：[/align]

[align=left][Pig[name=abc], Pig[name=abd], Pig[name=adc]][/align]

[align=left][Pig[name=adc], Pig[name=abd], Pig[name=abc]][/align]
[align=left]可见使用了自定义比较器以后，会覆盖掉实体类自身的比较器。重新进行排序。最终结果按照比较器进行排序。[/align]