Collections 使用java.util.Comparator接口排序

首先,比较Comparable和Comparator的区别

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

Comparable 是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作）;

而 Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

可以说一个是类自已完成比较，一个是外部程序实现比较的差别而已。

用 Comparator 是策略模式（strategy design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。

从操作上:Comparable 需要在被排序的类中实现其接口,而Comparator 是在被排序类的外部实现其接口即可.这样可以看出Comparable操作更简单,而Comparator操作复杂但是可以实现多种不同的排序方案.
 
比如：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不能去修改 Integer 类去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。

实现Comparator接口,实现排序

在Comparator接口里，只有一个方法是需要实现的：

Java代码

1. int compare(Object o1,Object o2);  

int compare(Object o1,Object o2);

提示:如果o1小于o2,返回一个负数;如果o1大于o2，返回一个正数;如果他们相等，则返回0;

注意:compare方法一定要是对称的，意思是compare(a,b)返回的结果要跟compare(b,a)相反。相反的结果意味着，要么返回的值带有不同的正负号，要么都是0。注意，象compare(a,b)返回4而compare(b,a)返回-2这样的情况是合法的。方法里常常可能抛出异常，在这个方法里抛出异常也要是对称的。如果调用compare(a,b)时抛出了一个ClassCastException异常,那么调用compare(b,a)时也必须抛出一个ClassCastException异常。

另外:任何你准备重用的Comparator都必须是可序列化的。TreeSet和TreeMap类存储Comparator以便进行比较，因此为了这两个类能被序列化，它们使用的Comparator也必须能被序列化。

Comparator接口，通常被Collections.sort方法使用，它是JAVA中需要了解的一个很重要的部分，因为它有一些重要的契约义务.

使用java.util.Comparator接口排序

DataBean.java

Java代码

1. package com.baomw;   
2.   
3. import java.io.Serializable;   
4. import java.text.MessageFormat;   
5.   
6. public class DataBean implements Serializable{   
7.   
8.     private static final long serialVersionUID = 1L;   
9.   
10.     private long id;   
11.     private String name;   
12.     private String sex;   
13.   
14.     public DataBean() {   
15.   
16.     }   
17.   
18.     public DataBean(long id, String name, String sex) {   
19.         this.id = id;   
20.         this.name = name;   
21.         this.sex = sex;   
22.     }   
23.   
24.     public long getId() {   
25.         return id;   
26.     }   
27.   
28.     public void setId(long id) {   
29.         this.id = id;   
30.     }   
31.   
32.     public String getName() {   
33.         return name;   
34.     }   
35.   
36.     public void setName(String name) {   
37.         this.name = name;   
38.     }   
39.   
40.     public String getSex() {   
41.         return sex;   
42.     }   
43.   
44.     public void setSex(String sex) {   
45.         this.sex = sex;   
46.     }   
47.   
48.     @Override  
49.     public String toString() {   
50.         return MessageFormat.format("id:{0},name:{1},sex:{2}", this.id,   
51.                 this.name, this.sex);   
52.     }   
53. }  

package com.baomw;

import java.io.Serializable;
import java.text.MessageFormat;

public class DataBean implements Serializable{

	private static final long serialVersionUID = 1L;

	private long id;
	private String name;
	private String sex;

	public DataBean() {

	}

	public DataBean(long id, String name, String sex) {
		this.id = id;
		this.name = name;
		this.sex = sex;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	public String toString() {
		return MessageFormat.format("id:{0},name:{1},sex:{2}", this.id,
				this.name, this.sex);
	}
}

说明:被排序的类

DemoComparator.java

Java代码

1. package com.baomw;   
2.   
3. import java.util.Comparator;   
4.   
5. public class DemoComparator implements Comparator<DataBean> {   
6.        
7.     private static DemoComparator demoComparator = null;   
8.        
9.     public static DemoComparator getInstance(){   
10.         if(demoComparator==null){   
11.             demoComparator = new DemoComparator();   
12.         }   
13.         return demoComparator;   
14.     }   
15.   
16.     @Override  
17.     public int compare(DataBean o1, DataBean o2) {   
18.         if (o1.getId() < o2.getId()) {   
19.             return -1;   
20.         } else if (o1.getId() > o2.getId()) {   
21.             return 1;   
22.         } else {   
23.             return 0;   
24.         }   
25.     }   
26. }  

package com.baomw;

import java.util.Comparator;

public class DemoComparator implements Comparator<DataBean> {
	
	private static DemoComparator demoComparator = null;
	
	public static DemoComparator getInstance(){
		if(demoComparator==null){
			demoComparator = new DemoComparator();
		}
		return demoComparator;
	}

	@Override
	public int compare(DataBean o1, DataBean o2) {
		if (o1.getId() < o2.getId()) {
			return -1;
		} else if (o1.getId() > o2.getId()) {
			return 1;
		} else {
			return 0;
		}
	}
}

说明:该类为Comparator接口的实现类,在被排序的类外部完成,并实现其compare方法,该方法判断id大小,最终按id次序进行排序.该类完成单例模式,只许一个对象即可实现其排序功能.

RunDemoMain.java

Java代码

1. package com.baomw;   
2.   
3. import java.util.ArrayList;   
4. import java.util.Collections;   
5. import java.util.List;   
6.   
7. public class RunDemoMain {   
8.   
9.     public static void main(String[] args) {   
10.         List<DataBean> dataBeans = new ArrayList<DataBean>();   
11.         dataBeans.add(new DataBean(23, "b", "w"));   
12.         dataBeans.add(new DataBean(34, "e", "w"));   
13.         dataBeans.add(new DataBean(12, "s", "w"));   
14.         dataBeans.add(new DataBean(10, "c", "w"));   
15.         dataBeans.add(new DataBean(19, "g", "w"));   
16.         dataBeans.add(new DataBean(78, "a", "w"));   
17.         dataBeans.add(new DataBean(66, "w", "w"));   
18.         dataBeans.add(new DataBean(50, "r", "w"));   
19.   
20.         System.out.println("==========排序前==========");   
21.         for (DataBean bean : dataBeans) {   
22.             System.out.println(bean);   
23.         }   
24.   
25.         DemoComparator comparator = DemoComparator.getInstance();   
26.   
27.         System.out.println("==========排序后==========");   
28.         Collections.sort(dataBeans, comparator);   
29.   
30.         for (DataBean bean : dataBeans) {   
31.             System.out.println(bean);   
32.         }   
33.     }   
34. }  

package com.baomw;

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

public class RunDemoMain {

	public static void main(String[] args) {
		List<DataBean> dataBeans = new ArrayList<DataBean>();
		dataBeans.add(new DataBean(23, "b", "w"));
		dataBeans.add(new DataBean(34, "e", "w"));
		dataBeans.add(new DataBean(12, "s", "w"));
		dataBeans.add(new DataBean(10, "c", "w"));
		dataBeans.add(new DataBean(19, "g", "w"));
		dataBeans.add(new DataBean(78, "a", "w"));
		dataBeans.add(new DataBean(66, "w", "w"));
		dataBeans.add(new DataBean(50, "r", "w"));

		System.out.println("==========排序前==========");
		for (DataBean bean : dataBeans) {
			System.out.println(bean);
		}

		DemoComparator comparator = DemoComparator.getInstance();

		System.out.println("==========排序后==========");
		Collections.sort(dataBeans, comparator);

		for (DataBean bean : dataBeans) {
			System.out.println(bean);
		}
	}
}

运行后显示:

Java代码

1. ==========排序前==========   
2. id:23,name:b,sex:w   
3. id:34,name:e,sex:w   
4. id:12,name:s,sex:w   
5. id:10,name:c,sex:w   
6. id:19,name:g,sex:w   
7. id:78,name:a,sex:w   
8. id:66,name:w,sex:w   
9. id:50,name:r,sex:w   
10. ==========排序后==========   
11. id:10,name:c,sex:w   
12. id:12,name:s,sex:w   
13. id:19,name:g,sex:w   
14. id:23,name:b,sex:w   
15. id:34,name:e,sex:w   
16. id:50,name:r,sex:w   
17. id:66,name:w,sex:w   
18. id:78,name:a,sex:w