博客

在Comparable接口中定义了compareTo方法：

public interface Comparable<T>
{
	int compareTo(T other);
}

在Comparator接口中，同样定义了compare方法：

public interface Comparator<T>
{
	int compare(T a,T b);
}

两种接口中的比较方法都分别返回负整数、0、正整数。

把元素插入TreeSet时，TreeSet默认实现Comparable接口中的compareTo方法进行排序，因此，可以通过重写comepareTo()方法控件TreeSet的排序方法。除此之外，通过实现Comparator接口，重写compare()方法可以实现同样功能。

以学生成绩排序为例子，以TreeSet存放学生信息，根据成绩自动排序。

但是，根据实际情况，当出现两个学生成绩相同时，TreeSet只保留了其中一个学生，而另一个学生的信息由丢失了，因此，在重写compare() 和compareTo()时要注意。完整代码如下：

1、Comparator接口

import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;
/**
 * 
 **实现按照学生成绩排序
 *
 **/
public class TestComparator {
	public static void main(String[] args) {
		SortedSet
  
  
   
   students=new TreeSet<>(new StudentComparator());
		//创建三个学生
		Student s1=new Student("Tom", 16, 82);
		Student s2=new Student("Lily", 18, 91);
		Student s3=new Student("Jay", 18, 82);
		students.add(s1);
		students.add(s2);
		students.add(s3);
		System.out.println(students);
	}
}

class StudentComparator implements Comparator
   
   
    
    {

	@Override
	public int compare(Student o1, Student o2) {
		int score1=o1.getScore();
		int score2=o2.getScore();
		//成绩不同则比较成绩
		//成绩相同则按姓名排序
		if(score1!=score2){
			return -(score1-score2);
		}else{
			return o1.getName().compareTo(o2.getName());
		}
	}
	
}

class Student{
	private String name;
	private int age;
	private int score;//成绩
	/**
	 * 构造函数
	 * */
	public Student(String name, int age, int score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public int getScore() {
		return score;
	}

	/**
	 * 以字符串形式输出
	 * */
	public String toString(){
		return name+"--"+age+"--"+score;
	}
}
   
   
  
  

2、Comparable接口

import java.util.SortedSet;
import java.util.TreeSet;
/**
 * 
 **实现按照学生成绩排序
 *
 **/
public class TestComparable {
	public static void main(String[] args) {
		SortedSet
   
   
    
    students=new TreeSet<>();
		//创建三个学生
		Student s1=new Student("Tom", 16, 82);
		Student s2=new Student("Lily", 18, 91);
		Student s3=new Student("Jay", 18, 82);
		students.add(s1);
		students.add(s2);
		students.add(s3);
		System.out.println(students);
	}
}


class Student implements Comparable
    
    
     
     {
	private String name;
	private int age;
	private int score;//成绩
	/**
	 * 构造函数
	 * */
	public Student(String name, int age, int score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	@Override
	public int compareTo(Student other) {
	    //成绩不同则比较成绩
		//成绩相同则按姓名排序
		if(score!=other.score){
			return -(score-other.score);
		}
		else{
			return name.compareTo(other.name);
		}
	}
	/**
	 * 以字符串形式输出
	 * */
	public String toString(){
		return name+"--"+age+"--"+score;
	}
}
    
    
   
   

两者比较，Comparable接口有一定局限，每个方法只能实现一次接口，当需求改变，如按年龄排序时，要回到Student类中修改CompareTo()方法，违背面向对象思想