java.lang.Comparable接口和java.util.Comparator接口

一：java.lang.Comparable：自然排序接口

• 1、抽象方法： int compareTo(Object obj)
  • 当前对象this 与 指定对象obj比较大小，
  • 当前对象 大于 指定对象obj时，返回正整数
  • 当前对象 小于 指定对象obj时，返回负整数
  • 当前对象 等于 指定对象obj时，返回零
  • 这里只是说明了参数和返回值的意义，并没有说按对象的哪个属性比较。
• 2、为什么要声明这个接口？
  • 因为JDK中的很多API都涉及到两个对象比较大小，那么如何统一这些操作标准呢，这个接口就是一个统一的标准。
  • 我们虽然不能对所有对象统一都按照某个属性比较大小，但是我们可以规定，凡是要支持比较大小的类型都要实现这个接口，并且重写
  • int compareTo(Object o)方法，返回正、负、0。

• 3、如何实现这个接口呢？

  接下来我们创建一个圆的对象数组，利用Comparable接口重写compareTo（）方法来实现排序

public class TestComparable {
   public static void main(String[] args) {		
   	Circle[] arr = new Circle[3];
   	arr[0]  = new Circle(1.2);
   	arr[1]  = new Circle(2.2);
   	arr[2] = new Circle(1);
   	
   	Arrays.sort(arr);
   	
   	for (int i = 0; i < arr.length; i++) {
   		System.out.println(arr[i]);
   	}
   }
}
class Circle implements Comparable{
   private double radius;

   public Circle(double radius) {
   	super();
   	this.radius = radius;
   }

   public Circle() {
   	super();
   }

   public double getRadius() {
   	return radius;
   }

   public void setRadius(double radius) {
   	this.radius = radius;
   }

   @Override
   public String toString() {
   	return "Circle [radius=" + radius + "]";
   }

   //假设这里要求，按照半径比较大小
   //这里参与比较大小的两个对象是  this 和  o 
   @Override
   public int compareTo(Object o) {
   	Circle other  = (Circle) o;
   	if(this.radius > other.radius){
   		return 1;
   	}else if(this.radius < other.radius){
   		return -1;
   	}
   	return 0;
   }
}
           

经过上面的例子我们发现java.lang.Comparable接口可以完成对象数组之间的排序，那么java.util.Comparator接口又是用来干嘛的呢？

java.util.Comparator接口也是用来排序，用于一些特殊情况

比如我们有一个学生类，属性有id，姓名，年龄，成绩，这时候要求按照年龄和成绩分别排序并输出。

之前我们利用java.lang.Comparable接口重写compareTo()方法，但compareTo()方法只有一个呀，如何同时实现两种不同的排序规则呢？这时候就用到了java.util.Comparator接口

二、java.util.Comparator

• 1、抽象方法：int compare(Object o1, Object o2)
  • 规定当o1 大于 o2时，返回正整数
  • 规定当o1 小于 o2时，返回负整数
  • 规定当o1 等于 o2时，返回0

public class TestComparator {
   public static void main(String[] args) {
   	Student[] arr = new Student[4];
   	arr[0] = new Student(2,"王小二",22,89);
   	arr[1] = new Student(3,"张三",23,78);
   	arr[2] = new Student(4,"李四",18,34);
   	arr[3] = new Student(5,"王五",26,99);

   	//java.util.Arrays数组工具类中已经定义了sort方法可以实现给元素排序
   	Arrays.sort(arr);

   	for (int i = 0; i < arr.length; i++) {
   		System.out.println(arr[i]);
   	}
   	System.out.println("---------------------------------------");
   	

   	//按照分数从高到低排序
   	Arrays.sort(arr, new StudentScoreCompare());
   	for (int i = 0; i < arr.length; i++) {
   		System.out.println(arr[i]);
   	}
   	System.out.println("---------------------------------------");
   	
   	//又有需求，按照年龄排序
   	Arrays.sort(arr, new StudentAgeCompare());//这时我们调用StudentAgeCompare()类里面我们写的另一个排序方法
   	for (int i = 0; i < arr.length; i++) {
   		System.out.println(arr[i]);
   	}
   }
}

//这里需要单独定制按照分数比较大小的比较器
class StudentScoreCompare implements Comparator{
   @Override
   public int compare(Object o1, Object o2) {
   	Student s1 = (Student) o1;
   	Student s2 = (Student) o2;
   	return s2.getScore() - s1.getScore();
   }
}

class Student implements Comparable{
   private int id;
   private String name;
   private int age;
   private int score;
   public Student(int id, String name, int age, int score) {
   	super();
   	this.id = id;
   	this.name = name;
   	this.age = age;
   	this.score = score;
   }
   public Student() {
   	super();
   }
   public int getId() {
   	return id;
   }
   public void setId(int id) {
   	this.id = id;
   }
   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 int getScore() {
   	return score;
   }
   public void setScore(int score) {
   	this.score = score;
   }
   @Override
   public String toString() {
   	return "Student [id=" + id + ", name=" + name + ", age=" + age + ", score=" + score + "]";
   }
   
   //默认是按照学号排序
   @Override
   public int compareTo(Object o) {
   	Student other = (Student) o;
   	return this.age - other.age;
   }
}