Java 之 Comparator接口与 Comparable 接口

时间:2019-11-27
本文章向大家介绍Java 之 Comparator接口与 Comparable 接口，主要包括Java 之 Comparator接口与 Comparable 接口使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

一、Comparator 接口

java.util.Comparator<T>接口：
    抽象方法：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表示；

　　需求：声明一个学生类，实现 comparator 接口，来定制两个学生比较的具体实现方式

　　Demo：

　　学生类：

 1 class Student{
 2     private String name;
 3     private int age;
 4     private int score;
 5     public Student(String name, int age, int score) {
 6         super();
 7         this.name = name;
 8         this.age = age;
 9         this.score = score;
10     }
11     public Student() {
12         super();
13     }
14     public String getName() {
15         return name;
16     }
17     public void setName(String name) {
18         this.name = name;
19     }
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26     public int getScore() {
27         return score;
28     }
29     public void setScore(int score) {
30         this.score = score;
31     }
32     @Override
33     public String toString() {
34         return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
35     }
36     
37 }
View Code

　　测试类：

 1 public class TestComparator {
 2     public static void main(String[] args) {
 3         Student s1 = new Student("小李子", 25, 89);
 4         Student s2 = new Student("小张字", 24, 99);
 5         
 6         
 7         AgeComparator c = new AgeComparator();
 8         if(c.compare(s1, s2) > 0){            //如果比较s1，s2的结果是正整数，说明s1>s2
 9             System.out.println("s1 > s2的年龄");
10         }else if(c.compare(s1, s2) <0){
11             System.out.println("s1 < s2的年龄");
12         }else{
13             System.out.println("s1 = s2的年龄");
14         }
15         
16         
17         Student[] all = new Student[5];
18         all[0] = s1;
19         all[1] = s2;
20         all[2] = new Student("张三",22,87);
21         all[3] = new Student("李四",24,44);
22         all[4] = new Student("王五",25,45);
23         
24         //Arrays工具类
25         //Arrays.sort(all);
26         /*
27          * public static void sort(Object[] a, Comparator c)
28          * 第一个形参：需要排序的数组，Object[]说明可以是任意类型的对象数组
29          * 第二个形参：比较器对象     Comparator接口不能创建对象，只能传入实现类对象
30          */
31         Arrays.sort(all, new AgeComparator());
32     
33         for (int i = 0; i < all.length; i++) {
34             System.out.println(all[i]);
35         }
36     }
37 }
38 
39 //实现Comparator接口，来定制两个学生比较的具体实现方式
40 //例如：按照年龄比较
41 class AgeComparator implements Comparator{
42 
43     @Override
44     public int compare(Object o1, Object o2) {
45         //（1）向下转型
46         Student s1 = (Student) o1;
47         Student s2 = (Student) o2;
48         
49         //（2）开始比较
50         if(s1.getAge() > s2.getAge()){
51             return 1;
52         }else if(s1.getAge() < s2.getAge()){
53             return -1;
54         }
55         return 0;
56     }
57     
58 }

二、Comparable 接口

java.lang.Comparable：自然比较，自然顺序
       int compareTo(Object obj)

　　this 与 obj 对象比较，this > obj，返回正整数；

　　this 与 obj 对象比较，this < obj，返回负整数；

　　this 与 obj 对象比较，this = obj，返回0；　　　

　对于上面的案例来说，如果希望学生对象本身就具备比较大小的能力。可以使学生实现 Comparable 接口。

　代码：

 1 public class TestComparable {
 2     public static void main(String[] args) {
 3         Student s1 = new Student("小李子", 25, 89);
 4         Student s2 = new Student("小张字", 24, 99);
 5         
 6         //按成绩比较
 7         if(s1.compareTo(s2)>0){
 8             System.out.println("s1 > s2成绩");
 9         }else if(s1.compareTo(s2)<0){
10             System.out.println("s1 < s2成绩");
11         }else{
12             System.out.println("s1 = s2成绩");
13         }
14         
15         
16     }
17 }
18 class Student implements Comparable{
19     private String name;
20     private int age;
21     private int score;
22     public Student(String name, int age, int score) {
23         super();
24         this.name = name;
25         this.age = age;
26         this.score = score;
27     }
28     public Student() {
29         super();
30     }
31     public String getName() {
32         return name;
33     }
34     public void setName(String name) {
35         this.name = name;
36     }
37     public int getAge() {
38         return age;
39     }
40     public void setAge(int age) {
41         this.age = age;
42     }
43     public int getScore() {
44         return score;
45     }
46     public void setScore(int score) {
47         this.score = score;
48     }
49     @Override
50     public String toString() {
51         return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
52     }
53     @Override
54     public int compareTo(Object obj) {
55         //this与obj比较，this和obj都是学生对象
56         Student other = (Student) obj;
57         //例如：对于学生对象来说，最常用的是按成绩排名，那么我就可以把自然顺序定位成绩升序
58 /*        if(this.score > other.score){
59             return 1;
60         }else if(this.score < other.score){
61             return -1;
62         }
63         return 0;*/
64         
65         return this.score - other.score;
66     }
67 }

　　总结：

　　　　Arrays 的 sort 方法有两种：

　　　（1）void sort(Object[] arr)

　　　　　  根据元素的自然顺序对指定对象数组按升序进行排序，数组中的所有元素必须实现 Comparable 接口。

　　　（2）void sort(Object[] arr, Comparator c)

　　　　　  根据“指定比较器”产生的顺序对指定对象数组进行排序，数组中的所有元素都必须是通过“指定比较器”可相互比较的。

原文地址：https://www.cnblogs.com/niujifei/p/11944983.html

随机文章
java知识点必读
最近更新