comparable 和 comparator 总结

comparable ：

让需要进行排序的对象实现Comparable接口，重写其中的compareTo(T o)方法，在其中定义排序规则，那么就可以直接调用

java.util.Arrays.sort()来排序对象数组

	比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

class Student implements Comparable<Student> {
	private String name;
	private int age;
	private float score;


	public Student(String name, int age, float score) {
		this.name = name;
		this.age = age;
		this.score = score;
	}


	public String toString() {
		return name +"***"+ age +"***"+ score;
	}


	@Override
	public int compareTo(Student o) {
		// score是private的，为什么能够直接调用,这是因为在Student类内部
		if (this.score > o.score)
			return -1;// 由高到底排序
		else if (this.score < o.score)
			return 1;
		else {
			if (this.age > o.age)
				return 1;// 由底到高排序
			else if (this.age < o.age)
				return -1;
			else
				return 0;
		}
	}
}


public class ComparableTest{


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu[] = { 
				new Student("张三", 20, 90.0f), 
				new Student("李四", 22, 90.0f),
				new Student("王五", 20, 99.0f), 
				new Student("赵六", 22, 100.0f) 
				};

		
		for (Student s : stu) {
			System.out.println(s);
		}
		System.out.println("************");
		java.util.Arrays.sort(stu);		for (Student s : stu) {			System.out.println(s);		}	}}

结果：

张三***20***95.0
李四***22***90.0
王五***20***99.0
赵六***22***100.0
************
赵六***22***100.0
王五***20***99.0
张三***20***95.0
李四***22***90.0

comparator：
public class Person {


	private String name;
	private int age;


	public Person() {


	}


	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;
	}


	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

import java.util.Comparator;


public class PersonComparator implements Comparator<Person>{


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


}

import java.util.Arrays;
public class ComparatorTest {
	 public static void main(String[] args) {
           Person[] persons = {
                   new Person("P1", 50),
                   new Person("P2", 30),
                   new Person("P3", 40)
        };
          
         System.out.println(Arrays.toString(persons));
         
         Arrays.sort(persons, new PersonComparator());
         
       System.out.println(Arrays.toString(persons));
       }
	 	
 }

结果：

[Person [name=P1, age=50], Person [name=P2, age=30], Person [name=P3, age=40]]
[Person [name=P2, age=30], Person [name=P3, age=40], Person [name=P1, age=50]]

总结：

comparable 和 comparator都是接口

comparable 在类中

comparator 类外类中没有变化

引用别人：comparator是策略模式的一种实现

策略模式：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化
引用地址：http://www.blogjava.net/jjshcc/archive/2011/04/12/348132.html