【Java】Comparable和Comparator两接口区别总结

Java 中为我们提供了两种比较机制：Comparable 和 Comparator。
两个词的意思都是比较的意思，但实际又是 可比较的 和 比较器。
所以很是疑惑。。。

1. Comparable 自然排序比较

java.lang 
public interface Comparable<T> {
	// 有且仅有 1 个公开抽象方法
	// 将此对象与指定的对象进行比较，返回正数、负数、0。  
	int compareTo(T o) 
}

Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareTo 方法中的规则进行，为 自然顺序比较。

compareTo 方法的返回值有 3 种情况：
正数 - 集合升序：e1.compareTo(e2) > 0 即 e1 > e2
零值 - 集合不变：e1.compareTo(e2) = 0 即 e1 = e2
负数 - 集合降序：e1.compareTo(e2) < 0 即 e1 < e2

自己定义的类如果想要使用有序的集合类，需要实现 Comparable 接口。
自己定义的类还需重写 equlas(), hashCode() 方法，为了保证类的对象比较的一致性。

代码示例：

public class TestComparable {
	public static void main(String[] args) {
		Teacher[] ts = new Teacher[] { 
				new Teacher("eric", 30), 
				new Teacher("abby", 29), 
				new Teacher("john", 22),
				new Teacher("sani", 33), };

		// Java中已有的接口、工具类，回调了现在写的 compareTo(Object o) 函数
		java.util.Arrays.sort(ts); // 调用工具
		for (Teacher teacher : ts) {
			System.out.println(teacher.toString());
		}
	}
}

class Teacher implements Comparable<Teacher> { // java.lang.Comparable
	String name;
	int age;

	public Teacher(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	// 需要根据接口进行抽象方法覆盖 - 参考JDK1.8手册
	@Override
	public int compareTo(Teacher o) {
		if (this.age > o.age) {
			return 1;
		} else if (this.age < o.age) {
			return -1;
		}

		return 0;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Teacher other = (Teacher) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Teacher [name=" + name + ", age=" + age + "]";
	}
}

输出：

2. Comparator 定制排序比较

java.util 
@FunctionalInterface // 函数式接口
public interface Comparator<T> {
	// 比较其两个参数。 
	int compare(T o1, T o2);
	// JDK1.8 之后增加了很多其他的静态方法...参见 API 文档
}

Comparator 则是在外部制定排序规则，然后作为排序策略参数传给某些类。
比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。

使用方式主要分三步：

1. 创建一个 Comparator 接口的实现类，并赋值给一个对象在 compare 方法中针对自定义类写排序规则；
2. 将 Comparator 对象作为参数传递给 排序类的某个方法；
3. 向排序类中添加 compare 方法中使用的自定义类。

public class TestComparator {
	public static void main(String[] args) {
		// 示例1：添加时遵循构造传入的 Comparator 的 compare 规则进行
		// 1.创建一个实现 Comparator 接口的对象
		Comparator<String> comparator = new Comparator<String>() {
			@Override
			public int compare(String object1, String object2) {
				// return 1: 长的被换到后面；-1: 短的被换到后面
				return object1.length() > object2.length() ? 1 : -1;
			}
		};

		// 2.将此对象作为形参传递给 TreeSet 的构造方法中
		TreeSet<String> treeSet = new TreeSet<String>(comparator);

		// 3.向 TreeSet 中添加 步骤 1 中 compare 方法中设计的类的对象
		treeSet.add(new String("a"));
		treeSet.add(new String("bbb"));
		treeSet.add(new String("ccccc"));
		treeSet.add(new String("dd"));
		System.out.println(treeSet.toString()); // [a, dd, bbb, ccccc]
		
		// 示例2：排序时遵循 Comparator 的 compare 规则，首字母大小
		List<String> list1 = Arrays.asList("ccc", "ddd", "aaa", "bbb");
		list1.sort(new Comparator<String>() {
			@Override 
			public int compare(String o1, String o2) {
				// 按首字符排序规则，return 1:首字母大的换到后面; -1:首字母小的换到后面
				return o1.charAt(0) > o2.charAt(0) ? 1 : -1;
			}
		});
		System.out.println(list1); // [aaa, bbb, ccc, ddd]
	}
}

输出结果：

3. 两者的比较总结

对于已定义好的普通包装数据类型（比如 String, Integer, Double…），它们默认实现了Comparable 接口，实现了 compareTo 方法，我们可以直接使用。

而对于我们自定义的类，它们可能在不同情况下需要实现不同的比较策略，我们可以新创建 Comparator 接口，然后实现特定的 compare 比较规则进行比较。