最近在学习贪心算法和动态规划的过程中，里面有一段自然排序的操作，顺便简单了解一下Java中对象比较后排序要使用的两个接口：Comparable和Comparator。如果是数字，直接比较就行，但是如果是对象，如何比较后排序呢？就需要用到这两个接口了，并且将自己定义的类作为参数传入接口泛型，在接口里重写比较方法，将自己要选择排序的类属性添加到比较条件中去。

接口主要区别

(1)Comparable接口是在java.lang下，Comparator接口是在java.util下。

(2)如果在定义类时，就实现了Comparable接口，直接在里面重写compareTo()方法，如果没实现，后面在业务开发中需要有比较排序的功能，就再单独写一个类实现Comparator接口，在里面重写compare()方法，然后这个类需要作为参数传入到工具类Collections.sort和Arrays.sort方法中。

(3)实现Comparable接口的类必须是自然排序，另外一个不是强制条件。

使用Comparable

(1)定义实现类时，实现Comparable接口。

1 /**

2 * 实体类，实现Comparable接口3 */

4 public class Person implements Comparable{5

6 //属性

7 privateString name;8 private intage;9 private intsalary;10

11 //get和set方法

12 publicString getName() {13 returnname;14 }15

16 public voidsetName(String name) {17 this.name =name;18 }19

20 public intgetAge() {21 returnage;22 }23

24 public void setAge(intage) {25 this.age =age;26 }27

28 public intgetSalary() {29 returnsalary;30 }31

32 public void setSalary(intsalary) {33 this.salary =salary;34 }35

36 //构造方法

37 public Person(String name, int age, intsalary) {38 this.name =name;39 this.age =age;40 this.salary =salary;41 }42

43 @Override44 publicString toString() {45 return "Person{" +

46 "name='" + name + '\'' +

47 ", age=" + age +

48 ", salary=" + salary +

49 '}';50 }51

52 //重写接口方法,o为要比较的对象

53 @Override54 public intcompareTo(Person o) {55 //大于要比较的对象就返回1

56 if(this.salary>o.getSalary()){57 return 1;58 }59 //小于则返回-1

60 else if(this.salary

64 return 0;65 }66 }

(2)测试类，来查看是否按照自定义的属性进行自然排序。

1 importjava.util.ArrayList;2 importjava.util.Collections;3 importjava.util.List;4

5 public classTestComparable {6

7 public static voidmain(String[] args) {8 //测试Comparable接口

9 Person p1=new Person("clyang",18,4000);10 Person p2=new Person("messi",30,8000);11 Person p3=new Person("ronald",32,9000);12 Person p4=new Person("herry",19,7600);13 Person p5=new Person("roben",35,7900);14

15 //添加到集合

16 List list=new ArrayList<>();17 list.add(p1);18 list.add(p2);19 list.add(p3);20 list.add(p4);21 list.add(p5);22

23 System.out.println("-----------------排序前-----------------");24 for(Person person : list) {25 System.out.println(person);26 }27

28 //排序一般使用Collections.sort方法，或者使用Arrays.sort方法，按照比较的元素进行自然排序，即从小到大

29 Collections.sort(list);30

31 System.out.println("-----------------排序后-----------------");32 for(Person person : list) {33 System.out.println(person);34 }35

36 }37 }

控制台输出情况，发现正常的按照工资进行了自然排序，即升序排列。

使用Comparator

使用这个接口时，创建类的时候可以不实现接口，需要单独创建一个类来实现这个接口。

(1)创建类

1 /**

2 * 实体类，不实现Comparable接口，使用单独的Comparator接口3 */

4 public classStaff {5

6 //属性

7 privateString name;8 private intage;9 private intsalary;10

11 public Staff(String name, int age, intsalary) {12 this.name =name;13 this.age =age;14 this.salary =salary;15 }16

17 publicString getName() {18 returnname;19 }20

21 public voidsetName(String name) {22 this.name =name;23 }24

25 public intgetAge() {26 returnage;27 }28

29 public void setAge(intage) {30 this.age =age;31 }32

33 public intgetSalary() {34 returnsalary;35 }36

37 public void setSalary(intsalary) {38 this.salary =salary;39 }40

41 @Override42 publicString toString() {43 return "Staff{" +

44 "name='" + name + '\'' +

45 ", age=" + age +

46 ", salary=" + salary +

47 '}';48 }49 }

View Code

(2)创建实现接口的类，重写里面的比较方法，这属于泛型在接口中的一种使用方法，即接口泛型是什么，实现类里面就是什么泛型。

1 importjava.util.Comparator;2

3 /**

4 * 单独写的比较器，实现Compartor接口5 */

6 public class StaffComparator implements Comparator{7

8 //不一定要自然排序即升序，可以反过来写成降序

9 @Override10 public intcompare(Staff o1, Staff o2) {11 //降序

12 /*if(o1.getSalary()>o2.getSalary()){13 return -1;14 }15 if(o1.getSalary()

19

20 //升序

21 /*if(o1.getSalary()>o2.getSalary()){22 return 1;23 }24 if(o1.getSalary()

28

29 //先按照年龄倒序排，如果年龄相等比较工资

30 if(o1.getAge()>o2.getAge()){31 return -1;32 }33 if(o1.getAge()

37 if(o1.getSalary()>o2.getSalary()){38 return 1;39 }40 if(o1.getSalary()

测试类，来查看是否按照自己的要求来排序。

1 importjava.util.ArrayList;2 importjava.util.Collections;3 importjava.util.Comparator;4 importjava.util.List;5

6 public classTestComparator {7

8 public static voidmain(String[] args) {9 //测试Comparator接口

10 Staff p1=new Staff("clyang",18,4000);11 Staff p2=new Staff("messi",30,8000);12 Staff p3=new Staff("ronald",32,9000);13 Staff p4=new Staff("herry",18,7600);14 Staff p5=new Staff("roben",35,7900);15

16 //添加到集合

17 List list=new ArrayList<>();18 list.add(p1);19 list.add(p2);20 list.add(p3);21 list.add(p4);22 list.add(p5);23

24 System.out.println("-----------------排序前-----------------");25 for(Staff staff : list) {26 System.out.println(staff);27 }28

29 //排序，需要使用自定义比较类

30 Comparator myComparator=newStaffComparator();31 Collections.sort(list,myComparator);32

33 System.out.println("-----------------排序后-----------------");34 for(Staff staff : list) {35 System.out.println(staff);36 }37 }38 }

控制台输出情况，可以发现，先是按照年龄进行了倒排序，当排到clyang和herry的时候，由于年龄相同，因此继续按照工资来升排序。

以上是两种接口的使用方法，也是参考了博主的文章学习的，以后可以拿来用。

参考博文：