Comparable和Comparator的区别和用法

                           Comparable和Comparator的区别和用法

 1、代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;
/**
 * 1、Comparable和Comparator的用法
 * 2、引用类型数组的排序和遍历	排序： Arrays.sort() 				   遍历：Arrays.Stream().forEach()
 * 3、引用类型集合的排序和遍历	排序：Collections.sort() list.sort()  遍历：list.forEach()
 * 4、Lambda表达式的使用
 * @author com
 *
 */
class Students implements Comparable<Students>{
	private int id;
	private String name;
	private int age;	//年龄
	private int score;	//分数
	Students(int id,String name,int age,int score){
		this.id = id;
		this.name = name;
		this.age = age;
		this.score = score;
	}
	public int getId() {
		return id;
	}
	public int getAge() {
		return age;
	}
	public int getScore() {
		return score;
	}
	@Override
	public String toString() {
		return id+","+name+","+age+","+score;
	}
	@Override
	public int compareTo(Students s) {
		return this.id - s.id;	//按id升序
	}
}
class StudentsComparator implements Comparator<Students>{
	@Override
	public int compare(Students s1,Students s2) {
		return s1.getScore() - s2.getScore();
	}
}
public class CompareTest {
	
	public static void main(String[] args) {
		Students s1 = new Students(1, "小白", 25, 99);
		Students s2 = new Students(2, "小黑", 22, 100);
		Students s3 = new Students(9, "小黄", 20, 98);
		Students s4 = new Students(4, "小蓝", 21, 97);
		Students s5 = new Students(5, "小红", 20, 95);
		Students[] stu = {s1,s2,s3,s4,s5};
		System.out.println("-----------------实现comparable接口-------------按id升序---------------------------------------");
		Arrays.sort(stu);
		Arrays.stream(stu).forEach(new Consumer<Students>() {
			@Override
			public void accept(Students s) {
				System.out.println(s);
			}
		});
		System.out.println("-----------------实现comparable接口-----匿名内部类重写------------按id降序--------------");
		Arrays.sort(stu, new Comparator<Students>() {
			@Override
			public int compare(Students s1, Students s2) {
				return s2.getId() - s1.getId();
			}
		});
		Arrays.stream(stu).forEach(System.out::println);
		System.out.println("-----------------实现comparable接口-------lambda表达式重写-------按年龄升序--------------");
		Arrays.sort(stu,(t1,t2)->{return t1.getAge()-t2.getAge();});
		Arrays.stream(stu).forEach(System.out::println);
		System.out.println("-----------------实现comparable接口-------lambda表达式重写-------按成绩升序--------------");
		Comparator<Students> comparator = new StudentsComparator();
		Arrays.sort(stu,comparator);
		Arrays.stream(stu).forEach(System.out::println);
		System.out.println("-----用ArraysList实现-----Collections.sort()方法调用的是默认(Comparable)的排序方法----按id升序-----------------");
		List<Students> list = new ArrayList<>();
		Collections.addAll(list, s1,s2,s3,s4,s5);
		Collections.sort(list);	//Collections.sort调用的是默认的排序方法
		list.forEach((s)->{System.out.println(s);});
		System.out.println("-----用List实现-----ArraysList.sort()方法以匿名内部类的形式实现Comparator接口的重写--------");
//		list.sort(comparator);	//List.sort()方法调用Comparator实现类接口
		list.sort(new Comparator<Students>() {
			@Override
			public int compare(Students t1,Students t2) {
				return t2.getScore() - t1.getScore();
			}
		});
		list.forEach(new Consumer<Students>() {
			@Override
			public void accept(Students s) {
				System.out.println(s);
			}
		});
		
	}
}

2、运行效果 

3、总结

对于引用类型的数组和引用类型的集合，需要自己定义规则才能对其进行排序。

其中有两个方法可以实现：Comparable<T>和Comparator<T>

（1）、需要排序的类实现Comparable接口和重写comparaTo()方法

（2）、自己写一个比较类class，实现Comparator接口并重写compare()方法

（3）、匿名内部类去实现comparator接口，重写compare()方法自己定义排序。

（4）、Lambda表达式实现comparator接口，重写compare()方法自己定义排序。

（5）、引用类型数组方法

              排序： Arrays.sort()

              遍历：Arrays.Stream().forEach()

（6）、引用类型集合方法

             排序：Collections.sort()   list.sort()  

             遍历：list.forEach()

4、注意

Comparable接口和Comparator接口都是函数式接口，因此可以用Lambda表达式去重写它的抽象方法。

Comparable接口重写comparator(T o)方法，Comparator接口重写compare(T o1, T o2)方法。

实现接口和重写方法时，注意指定的泛型类型是需要比较的类class。