一、常用接口：java.util.Comparator（1）
1、引入
java.util.Comparator接口：抽象方法：int compare(T o1, T o2)
因为是泛型，我们还没讲。现在就把T擦除，换成Object
java.util.Comparator接口： 抽象方法：int compare(Object o1, Object o2)
这个接口是代表Java中比较两个对象的大小标准。而且是一种“定制”比较的标准。
这个接口中没有规定如何比较两个对象的大小，
但是规定了，如果你认为o1 大于 o2，就返回正整数表示,如果你认为o1 小于 o2，就返回负整数表示,如果你认为o1 等于 o2，就返回0表示*/
2、举例
如下：”声明一个 Student，并且对它进行属性、构造器、get/set 和方法内容描写，最后加一个重写：toString()
下面我们怎么做呢？我们在main()方法里面建立两个学生对象
所以java中规定，你要对象比较就必须使用Comparator
那么怎么实现Comparator呢？
再根据提示重写
这样，其实也访问不了学生的属性
所以要向下转型
创建完AgeComparator类，重写完Comparator后就可以用了
3、扩展
如果想按照成绩怎么办？
再实现一遍即可
此部分完整代码如下：
/* java.util.Comparator<T>接口：
抽象方法：int compare(T o1, T o2)
因为<T>是泛型，我们还没讲。现在就把T擦除，换成Object
java.util.Comparator接口：
抽象方法：int compare(Object o1, Object o2)
这个接口是代表Java中比较两个对象的大小标准。而且是一种“定制”比较的标准。
这个接口中没有规定如何比较两个对象的大小，
但是规定了，如果你认为o1 大于 o2，就返回正整数表示,如果你认为o1 小于 o2，就返回负整数表示,如果你认为o1 等于 o2，就返回0表示*/
package com.atguigu.test03;
import java.util.Comparator;
public class TestComparator {
public static void main(String[] args) {
Student s1=new Student("张三",20,80);
Student s2=new Student("李四",23,99);
//比较s1和s2的大小
/* if(s1 > s2){//错误的
System.out.println("s1 > s2");
}*/
//所以java中规定你要对象比较就必须使用Comparator，那么怎么实现Comparator呢？
//创建完AgeComparator类，重写完Comparator后就可以用了
AgeComparator a=new AgeComparator();
if(a.compare(s1, s2)>0){
System.out.println("s1 > s2的年龄");
}
else if(a.compare(s1, s2)<0){
System.out.println("s1 < s2的年龄");
}
else{
System.out.println("s1 = s2的年龄");
}
//（3）、扩展
//创建完ScoreComparator类，重写完Comparator后就可以用了
ScoreComparator s=new ScoreComparator();
if(s.compare(s1, s2)>0){
System.out.println("s1 > s2的成绩");
}
else if(s.compare(s1, s2)<0){
System.out.println("s1 < s2的成绩");
}
else{
System.out.println("s1 = s2的成绩");
}
}
}
//实现Comparator接口，来定制学生比较的具体方式
//例如：按年龄比较
class AgeComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//(1)向下转型
Student s1=(Student)o1;
Student s2=(Student)o2;
//（2）开始比较
if(s1.getAge()>s2.getAge()){
return 1;
}
else if(s1.getAge()<s2.getAge()){
return -1;
}
return 0;
}
}
//3、扩展
//实现Comparator接口，来定制学生比较的具体实现方式
//例如再加一个按成绩比较，再实现一遍即可
class ScoreComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//(1)向下转型
Student s1=(Student)o1;
Student s2=(Student)o2;
//(2)开始比较
if(s1.getScore()>s2.getScore()){
return 1;
}
else if(s1.getScore()<s2.getScore()){
return -1;
}
else{
return 0;
}
}
}
//声明一个 Student
class Student{
//属性
private String name;
private int age;
private int score;
//构造器
public Student() {
super();
}
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
//get/set
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//重写toString()
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
}
4、思考一个问题，比较有什么用呢？
除了以上的例子可以用到外还有别的什么地方能用到吗？
试试数组
因为你没具体说按什么排序啊
再看API文档
至于它内部怎么排序，我们先不管，原理跟我们前面是一样的
至此，完整代码如下：
package com.atguigu.test03;
import java.util.Arrays;
import java.util.Comparator;
public class TestComparator {
public static void main(String[] args) {
Student s1=new Student("刘一",20,80);
Student s2=new Student("陈二",23,99);
//比较s1和s2的大小
/* if(s1 > s2){//错误的
System.out.println("s1 > s2");
}*/
//所以java中规定你要对象比较就必须使用Comparator，那么怎么实现Comparator呢？
//创建完AgeComparator类，重写完Comparator后就可以用了
AgeComparator a=new AgeComparator();
if(a.compare(s1, s2)>0){
System.out.println("s1 > s2的年龄");
}
else if(a.compare(s1, s2)<0){
System.out.println("s1 < s2的年龄");
}
else{
System.out.println("s1 = s2的年龄");
}
//（3）、扩展
//创建完ScoreComparator类，重写完Comparator后就可以用了
ScoreComparator s=new ScoreComparator();
if(s.compare(s1, s2)>0){
System.out.println("s1 > s2的成绩");
}
else if(s.compare(s1, s2)<0){
System.out.println("s1 < s2的成绩");
}
else{
System.out.println("s1 = s2的成绩");
}
//4、除了以上的例子可以用到外还有别的什么地方能用到吗?有，比如：数组
Student [] all =new Student[5];
all[0]=s1;
all[1]=s2;
all[2]=new Student("张三",25,70);
all[3]=new Student("李四",23,70);
all[4]=new Student("张三",26,70);
//Arrays.sort(all);直接使用会报错
//public static <T> void sort(T[] a, Comparator<? super T> c)
//改成如下：
//public static void sort(Object[] a, Comparator c)
Arrays.sort(all,new AgeComparator());//这样就按年龄排序了
for (int i = 0; i < all.length; i++) {
System.out.println(all[i]);
}
}
}
//实现Comparator接口，来定制学生比较的具体方式
//例如：按年龄比较
class AgeComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//(1)向下转型
Student s1=(Student)o1;
Student s2=(Student)o2;
//（2）开始比较
if(s1.getAge()>s2.getAge()){
return 1;
}
else if(s1.getAge()<s2.getAge()){
return -1;
}
return 0;
}
}
//3、扩展
//实现Comparator接口，来定制学生比较的具体实现方式
//例如再加一个按成绩比较，再实现一遍即可
class ScoreComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//(1)向下转型
Student s1=(Student)o1;
Student s2=(Student)o2;
//(2)开始比较
if(s1.getScore()>s2.getScore()){
return 1;
}
else if(s1.getScore()<s2.getScore()){
return -1;
}
else{
return 0;
}
}
}
//声明一个 Student
class Student{
//属性
private String name;
private int age;
private int score;
//构造器
public Student() {
super();
}
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
//get/set
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//重写toString()
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
}
二、常用接口：java.util.Comparator（2）
下面我们来看一个全新的需求
我们没法写，但是又有这个需求怎么办，这就需要我吗遵循java规范
标准就是你不仅给我传一个数组，还得给我传一个比较器的对象进来而且 java.util.Comparator 是JDK的核心类库中的写好的，不要我们自己写，直接导进来就行了
至此写完了吗？但是大家注意，我们现在只是写了算法，你知道将来这个算法用来比较什么的吗？实际上不知道
那我们新建一个测试类来使用它
怎么用呢？首先得有一个数组
为了直观，加几行代码如下：
运行效果如下：
完整代码：
结构如下：
TestComparator2类：
package com.atguigu.test04;
import com.atguigu.test04.Student;
public class TestComparator2 {
//需求：编写一个MyArrays的数组工具类，这个工具类，想要为任意的对象数组，进行升序排序
public static void main(String[] args) {
Student [] all =new Student[5];
all[0]=new Student("刘一",20,80);
all[1]=new Student("陈二",23,99);
all[2]=new Student("张三",25,70);
all[3]=new Student("李四",23,70);
all[4]=new Student("张三",26,70);
AgeComparator c = new AgeComparator();
MyArrays.sort(all, c);
System.out.println("-------------------------");
for (int i = 0; i < all.length; i++) {
System.out.println(all[i]);//打印对象
}
}
}
Student：
package com.atguigu.test04;
class Student{
//属性
private String name;
private int age;
private int score;
//构造器
public Student() {
super();
}
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
//get/set
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//重写toString()
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
}
MyArrays类
package com.atguigu.test04;
import java.util.Comparator;
//需求：编写一个MyArrays的数组工具类，这个工具类，想要为任意的对象数组，进行升序排序
public class MyArrays {
//这只是算法，怎么使用？具体到底是比较什么
public static void sort(Object[] arr,Comparator c){
for(int i= 1;i < arr.length; i++){
System.out.println("第"+i+"轮");
for (int j = 0; j < arr.length-i; j++) {
//为了更直观
System.out.println("比较：arr["+j+"]和arr["+(j+1)+"]");
System.out.println(arr[j]);
System.out.println(arr[j+1]);
//这里是冒泡排序法，记死的也行
//if (arr[j]>arr[j+1])
if (c.compare(arr[j], arr[j+1])>0) {
Object temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
AgeComparator类：
package com.atguigu.test04;
import java.util.Comparator;
//需求：编写一个MyArrays的数组工具类，这个工具类，想要为任意的对象数组，进行升序排序
public class MyArrays {
//这只是算法，怎么使用？具体到底是比较什么
public static void sort(Object[] arr,Comparator c){
for(int i= 1;i < arr.length; i++){
System.out.println("第"+i+"轮");
for (int j = 0; j < arr.length-i; j++) {
//为了更直观
System.out.println("比较：arr["+j+"]和arr["+(j+1)+"]");
System.out.println(arr[j]);
System.out.println(arr[j+1]);
//这里是冒泡排序法，记死的也行
//if (arr[j]>arr[j+1])
if (c.compare(arr[j], arr[j+1])>0) {
Object temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
三、最后图解
