Comparable和Comparator的使用

前言：

|ू･ω･` )
Comparable和Comparator的类看起来是非常相同的，同时用起来也是差不多的用途：比较

为什么要学习呢？
因为JDK的大量的类包括常见的 String、Byte、Char、Date等都实现了Comparable接口，因此要学习一下这两个类的区别以及用法

---

Comparable

首先Comparable可以算是“内部比较器”，因为大部分类一旦实现了Comparable，也就是说这个类支持“排序”
ok,那一个类该怎么实现:

public class person implements Comparable<person>{
	
	private String name;
	private int age;
	
	public person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	@Override
	public int compareTo(person o) {
		// TODO Auto-generated method stub
		return this.age-o.age;                 (对Int类型排序); 
	 // return this.name.compareTo(o.name);    (对String类型排序);
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name+":"+age;
	}
}

因为person类实现了接口Comparable,所以写了compareTo()方法；
方法的返回：

1. 比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数
2. 比较者等于被比较者，那么返回0
3. 比较者小于被比较者，那么返回负整数

调用：

public static void main(String[] args) {
		ArrayList<person> ap = new ArrayList<>();
		ap.add(new person("bb", 18));
		ap.add(new person("bb", 15));
		ap.add(new person("aa", 16));
		System.out.println(ap);
		Collections.sort(ap);
		System.out.println(ap);
	}

结果：

[bb:18, cc:15, aa:16]
[cc:15, aa:16, bb:18]

当然如果是对string排的话：

[bb:18, cc:15, aa:16]
[aa:16, bb:18, cc:15]

---

Comparator

Comparator的话，相对而言是“外部比较器”.一般使用的情况就是在一个类想与内部对象比较却没办法比较（没有实现Comparable）。
那么，它的类假设为：

public final class person2 {
	private String name;
	private int age;
	
	public person2(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name+":"+age;
	}

这个已经被final定死,但是还是想比较：
这个时候就可以用到Comparator:

public static void main(String[] args) {
		ArrayList<person2> ap2 = new ArrayList<>();
		
		ap2.add(new person2("bb", 18));
		ap2.add(new person2("bb", 15));
		ap2.add(new person2("aa", 16));
		
		System.out.println(ap2);
		Collections.sort(ap2, new Comparator<person2>() {
			@Override
			public int compare(person2 o1, person2 o2) {
				// TODO Auto-generated method stub
				if(o1==null&&o2==null) {
					return 0;
				}
				return o1.age-o2.age;   (对Int类型排序); 
			//  return o1.compare(o2);  (对String类型排序); 
			}
		});
		System.out.println(ap2);
	}

方法的返回：

1. o1大于o2，返回正整数
2. o1等于o2，返回0
3. o1小于o2，返回负整数

也就是直接在外部实现Comparator（策略模式）
结果：

[bb:18, cc:15, aa:16]
[cc:15, aa:16, bb:18]

总结

前者相对比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。所以说前者属于 “静态绑定”，而后者可以 “动态绑定”

---

Thanks♪(･ω･)ﾉ 感谢大家能够参考