Comparable接口和Comparator接口的区别与使用

一、Comparable用法

1、一个类在设计之时就要实现对该类对象的排序功能，那么这个类要实现Comparable接口，实现public int compareTo(T t)方法。如代码中的Student类。

• 对于实现Comparable接口的类：
  1. 调用java.util.Arrays.sort(Object[] a)对包含对象实例的数组进行排序。
  2. 调用java.util.Collections.sort(List list)对包含对象实例的list进行排序。

2、若一个类在设计之初并没有对排序功能的需求，而在后续的使用中想要对这个类增加排序的功能，如Student类。这时的办法是实现一个比较器类。
例如:StudentComparator类，实现public int compare(T t1, T t2)让该类实现Comparator接口。
调用java.util.Arrays.sort(T[] a, Comparator<? super T> c) 对包含对象实例的数组进行排序。
调用java.util.Collections.sort(List list, Comparator<? super T> c) 对包含对象实例的list进行排序。

3、a.compareTo(b)方法和compare(a,b)方法，在方法中判断两个对象的某个或某些属性的大小关系，若a的某个属性比b的属性小，返回负整数，若相等，返回0，否则返回正整数。

// 按照某属性从小到大排序
if (a.attr < b.attr) {
	return -1;
} else {
	return 1;
}

// 从大到小排序
if (a.attr < b.attr) {
	return 1;
} else {
	return -1;
}

import java.util.Arrays;

class Student implements Comparable<Student> {
	 private String name;
	 private int 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 int compareTo(Student stu) {
		return this.age -stu.age;
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
}
public class TestSort {
	public static void main(String[] args) {
		// 排序测试
		Student[] students = new Student[] {
				new Student("小李",15),
				new Student("小张",11),
				new Student("小李",18)
				};
		System.out.println(Arrays.toString(students));
		Arrays.sort(students);
		System.out.println(Arrays.toString(students));
	}
}

二、Comparator

对于已经实现了Comparable接口的集合，或者是不想实现Comparable接口的集合可以通过另一种方式来排序，就是利用Comparator接口。

public class TestCallBack {
	public static void main(String[] args) {
		// 需求:给一组学生对象排序
		  Student[] students = new Student[3];
		  students[0] = new Student("tom",22,"male",99.1);
          students[1] = new Student("jack",20,"male",99.0);
          students[2] = new Student("male",21,"male",99.0);
		System.out.println(Arrays.toString(students));
		// 方法2
		Arrays.sort(students,new Comparator<Student>() {
				@Override
				public int compare(Student o1, Student o2) {
					return o1.getAge() - o2.getAge();
				}
		});
		System.out.println(Arrays.toString(students));
	}
}

class Student{
	private String name;
	private int age;
	private String sex;
	private double score;
	
	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 String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + "]";
	}
	public Student(String name, int age, String sex, double score) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.score = score;
	}
}

接口中有一个方法叫做compare，里边包含两个参数：如里边包含两个参数：如果用第一个和第二个做比较得到的就是升序，反之得到的就是降序。

Comparable接口位于 java.lang包下，Comparator接口位于java.util包下。

Comparable: 内部比较器，一个类如果想要使用 Collections.sort(list) 方法进行排序，则需要实现该接口

Comparator: 外部比较器用于对那些没有实现Comparable接口或者对已经实现的Comparable中的排序规则不满意进行排序.无需改变类的结构，更加灵活。（策略模式）