接口comparable和接口comparator的比较

 

一.相关概念

Comparable和Comparator都是用来实现集合中元素的比较、排序的。
   （一） Comparable

Comparable是在集合内部定义的方法实现的排序，位于java.util下。是一个对象本身就已经支持自比较所需要实现的接口，如String、Integer自己就实现了Comparable接口，可完成比较大小操作。自定义类要在加入list容器中后能够排序，也可以实现Comparable接口，在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。

  （二）Comparator

Comparator是在集合外部实现的排序，位于java.lang下。是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。使用方法只能用Collections类的sort方法，并且是传递两个参数进去（List list，Class class），第一个参数是集合的对象list，第二个是实现了comparator接口的实现类的对象。

 

总而言之Comparable是自已完成比较，Comparator是外部程序实现比较。

（一）Comparable用法

 

（1）Comparable是一个接口，需要实现后才能使用， 比如：要对User这个对象的某个属性来排列显示时，Comparable被实现时需要在后面添加泛型如：类名 implements Comparable<User>

   （2）实现接口后要重写方法compareTo（只有一个参数），

   （3）如果比较的的数字，方法返回number-Object.number

   （4）如果比较的的字符串，方法返回string.equal(Object.string)

   （5）正常是按升序排列，在返回前面加个负号就可以降序排列

三种方法：

（一）自然排序

（二）匿名内部类

（三）lambda表达式

package day8_14;
import java.util.Arrays;
import java.util.Comparator;
class Student implements Comparable<Student> {
	private int no;
	private int score;
	public Student(int no, int score) {
		super();
		this.no = no;
		this.score = score;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public int compareTo(Student o) {
		/*if (o.score > this.score) {
			return 1;
		} else if (o.score < this.score) {
			return -1;
		} else {
			return 0;
		}*/
		return o.score-this.score;
	}
	@Override
	public String toString() {
		return "编号" + no + "分数" + score;
	}
}

public class TestSort1 {
	public static void main(String[] args) {
//		Student[] arr = new Student[3];
		Student zhangsan = new Student(2, 70);
		Student lisi = new Student(3, 90);
		Student wangwu = new Student(1, 80);
		/*arr[0] = zhangsan;
		arr[1] = lisi;
		arr[2] = wangwu;*/
		Student [] arr= {zhangsan,lisi,wangwu};
		//自然排序
//		Arrays.sort(arr);		
		//匿名内部类
		Arrays.sort(arr,new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				return o1.getNo()-o2.getNo();
			}		
		});
		//lambda表达式
//		Arrays.sort(arr, (stu1,stu2)->stu1.getNo()-stu2.getNo());
		Arrays.sort(arr, (stu1,stu2)->{return stu1.getNo()-stu2.getNo();});
		for (Student n : arr) {
			System.out.println(n.toString());
		}
	}
}

（二）Comparator用法

 1. 功能：按照存储的对象的某个属性排列来显示该对象的所有属性，只能对任意集合List接口下的实现类ArrayList和LinkedList进行排序

2.使用方法：

    （1）需要在另一个类是实现Comparator，同样后面也要加泛型，这个泛型是需要排序的自定义类

    （2）要重写compare方法，比较Object里面的具体属性用compareTo

   （3）需要Collections工具类的sort方法，方法里面传入两个参数：第一个参数是列表信息list，第二个参数是实现了comparator的类的对象

两种用法

（一）匿名内部类

（二）lambda表达式

package point;
import java.util.Arrays;
import java.util.Comparator;
class VIP1 implements Comparator<VIP1>{
	private int no;
	private String name;
	private int score;	
	public VIP1(int no, String name, int score) {
		super();
		this.no = no;
		this.name = name;
		this.score = score;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "VIP [no=" + no + ", name=" + name + ", score=" + score + "]";
	}
	@Override
	public int compare(VIP1 o1, VIP1 o2) {
		return 0;
	}
}
public class Demo4 {
	public static void main(String[] args) {
		VIP1 zhangsan = new VIP1(1, "张三", 80);
		VIP1 lisi = new VIP1(3, "李四", 90);
		VIP1 wangwu = new VIP1(2, "王五", 70);
		VIP1 [] arr = {zhangsan,lisi,wangwu};
		/*Arrays.sort(arr,new Comparator<VIP1>() {
			@Override
			public int compare(VIP1 o1, VIP1 o2) {
				return o1.getScore()-o2.getScore();
			}
			
		});*/
		Arrays.sort(arr,(v1,v2)->{return v1.getNo()-v2.getNo();});
		for(VIP1 n :arr) {
			System.out.println(n);
		}
	}
}