外部比较器

外部比较器可以说是内部比较器的加强版，它在封装类的外面可以定义多个类来对不同的功能进行实现，如果说是内部比较器的话，重写方法，只能返回一个值，如果说有多个功能实现的话会比较麻烦。如果使用外部比较器就可以定义可能会需要的功能程序，实现起来就会相对来说简单很多。
第一步，定义排序代码实现图示：

源码+注释展示：

//定义一个排序方法，需要用到的时候直接在其他主方法直接调用即可
		public static void sort(Object[] arr,Comparator com){//定义一个排序方法
			for (int i = 1; i <= arr.length-1; i++) {//对数组进行遍历，定义数组比较的两个元素
				for (int j = i; j <= arr.length-1; j++) {					
					if (com.compare(arr[i-1], arr[j])>0) {//如果前面一个值大于后面一个值，那么将会执行下面的操作，否则不执行里面的语句
						Object temp = arr[i-1];//在这里主要执行的是一个交换的工作，数组大的往后放，小的往前
						arr[i-1] = arr[j];//将小的值给到i-1
						arr[j] = temp;//最后完成交换
					}
				}
			}
		}

第二步，定义一个封装类，然后使用外部排序的方法实现多个功能的实现，在需要用到要用的功能时直接进行new对象即可进行使用。图示如下：



正如上图所示，在封装类的外部实现接口Comparator，然后进行功能实现的程序设计。
源码+注释：

import java.util.Comparator;
public class Student{//实现compareTo接口
	private String name;
	private int age;
	private double score;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	public Student(String name, int age, double score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
	}
}
class Campare implements Comparator{//表示的是该类实现接口Comparator，需要进行重写

	@Override
	public int compare(Object o1, Object o2) {
		Student s1=(Student)o1;
		Student s2=(Student)o2;
		return s1.getAge()-s2.getAge();
	}
}
//对名字进行排序
class Campare01 implements Comparator{//表示的是该类实现接口Comparator，需要进行重写

	@Override
	public int compare(Object o1, Object o2) {
		Student s1=(Student)o1;
		Student s2=(Student)o2;
		return s1.getName().compareTo(s2.getName());
	}
}	

第三步，主程序中定义对象并进行对对象进行赋值，进行对需要使用的对象进行new，然后调用排序的方法，并打印其所需的内容：

源码+注释展示：

import java.util.Arrays;

public class Test {
	public static void main(String[] args) {	
		Student s = new Student("Tom",15,63);//定义对象并进行赋值
		Student s1 = new Student("Je",14,59);
		Student s2 = new Student("TomSun",16,56.7);
		Student[] student = new Student[4];
		student[0] = s;
		student[1] = s1;
		student[2] = s2;
		student[3] = new Student("Join",13,65);
		//按照年龄进行比较 从小到大
		Campare cap = new Campare();
		ArraysUntil.sort(student,cap);
		System.out.println(Arrays.toString(student));
	}
}

为了节省代码，我们还可以在主程序当中定义一个匿名内部类，其他不变，就是增加了一个匿名内部类。图示如下：


在上图中我们可以发现，注释掉得内部类与下面的是一样的，上面的只是为了理解，那样会更清晰，意思一样。只是上面一个看起来会更清晰。如下图示：

源码展示：

package Test02;

import java.util.Arrays;
import java.util.Comparator;

public class Test {//外部比较器
	public static void main(String[] args) {	
		Student s = new Student("Tom",15,63);//定义对象并进行赋值
		Student s1 = new Student("Je",14,59);
		Student s2 = new Student("TomSun",16,56.7);
		Student[] student = new Student[4];
		student[0] = s;
		student[1] = s1;
		student[2] = s2;
		student[3] = new Student("Join",13,65);
		//按照年龄进行比较 从小到大
//		Campare cap = new Campare();
//		Campare01 cap = new Campare01();
		//定义一个匿名内部类
//		Comparator com = new Comparator() {
//
//			@Override
//			public int compare(Object o1, Object o2) {//对成绩进行排序
//				Student s1=(Student)o1;
//				Student s2=(Student)o2;
//				return ((Double)s1.getScore()).compareTo((Double)s2.getScore());//将其转成对应的包装类
//			}
//			
//		};
		ArraysUntil.sort(student,new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {//对成绩进行排序
				Student s1=(Student)o1;
				Student s2=(Student)o2;
				return ((Double)s1.getScore()).compareTo((Double)s2.getScore());//将其转成对应的包装类
			}
			
		});
		System.out.println(Arrays.toString(student));
	}
}

结束语：外部比较器会更方便，当然有时候内部比较器也有它的优点，两者之间的关系很紧密，两者之间的实现是差不多的。