Java中Comparable和Comparator的区别

举报
经典鸡翅 发表于 2022/02/17 23:49:57 2022/02/17
【摘要】 前言 最近复习遇到了这个问题,在此进行一个详细的记录,分享给大家。 两个接口的区别 包区别 Comparable接口是在java.lang下。 Comparator接口是在java.util下。 使用区别 如果在定义类时,就实现了Comparable接口,直接在里面重写compareTo()方法,如果没实现...

前言

最近复习遇到了这个问题,在此进行一个详细的记录,分享给大家。

两个接口的区别

包区别

Comparable接口是在java.lang下。
Comparator接口是在java.util下。

使用区别

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

使用场景

主要用于集合排序Collections.sort和Arrays.sort。

使用Comparable接口的实现方案

在定义类的时候,就实现这个接口,将排序规则定义好。


   
  1. /**
  2. * 实体类,实现Comparable接口
  3. */
  4. public class Person implements Comparable<Person>{
  5. //属性
  6. private String name;
  7. private int age;
  8. private int salary;
  9. //get和set方法
  10. public String getName() {
  11. return name;
  12. }
  13. public void setName(String name) {
  14. this.name = name;
  15. }
  16. public int getAge() {
  17. return age;
  18. }
  19. public void setAge(int age) {
  20. this.age = age;
  21. }
  22. public int getSalary() {
  23. return salary;
  24. }
  25. public void setSalary(int salary) {
  26. this.salary = salary;
  27. }
  28. //构造方法
  29. public Person(String name, int age, int salary) {
  30. this.name = name;
  31. this.age = age;
  32. this.salary = salary;
  33. }
  34. @Override
  35. public String toString() {
  36. return "Person{" +
  37. "name='" + name + '\'' +
  38. ", age=" + age +
  39. ", salary=" + salary +
  40. '}';
  41. }
  42. //重写接口方法,o为要比较的对象
  43. @Override
  44. public int compareTo(Person o) {
  45. //大于要比较的对象就返回1
  46. if(this.salary>o.getSalary()){
  47. return 1;
  48. }
  49. //小于则返回-1
  50. else if(this.salary<o.getSalary()){
  51. return -1;
  52. }
  53. //相等则返回0
  54. return 0;
  55. }
  56. }

测试方法:


   
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. public class TestComparable {
  5. public static void main(String[] args) {
  6. //测试Comparable接口
  7. Person p1=new Person("clyang",18,4000);
  8. Person p2=new Person("messi",30,8000);
  9. Person p3=new Person("ronald",32,9000);
  10. Person p4=new Person("herry",19,7600);
  11. Person p5=new Person("roben",35,7900);
  12. //添加到集合
  13. List<Person> list=new ArrayList<>();
  14. list.add(p1);
  15. list.add(p2);
  16. list.add(p3);
  17. list.add(p4);
  18. list.add(p5);
  19. System.out.println("-----------------排序前-----------------");
  20. for (Person person : list) {
  21. System.out.println(person);
  22. }
  23. //排序一般使用Collections.sort方法,或者使用Arrays.sort方法,按照比较的元素进行自然排序,即从小到大
  24. Collections.sort(list);
  25. System.out.println("-----------------排序后-----------------");
  26. for (Person person : list) {
  27. System.out.println(person);
  28. }
  29. }
  30. }

使用Comparator

这个接口主要用于实体创建的时候,没有实现接口,但又需要比较的情况。


   
  1. /**
  2. * 实体类,不实现Comparable接口,使用单独的Comparator接口
  3. */
  4. public class Staff {
  5. //属性
  6. private String name;
  7. private int age;
  8. private int salary;
  9. public Staff(String name, int age, int salary) {
  10. this.name = name;
  11. this.age = age;
  12. this.salary = salary;
  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 getSalary() {
  27. return salary;
  28. }
  29. public void setSalary(int salary) {
  30. this.salary = salary;
  31. }
  32. @Override
  33. public String toString() {
  34. return "Staff{" +
  35. "name='" + name + '\'' +
  36. ", age=" + age +
  37. ", salary=" + salary +
  38. '}';
  39. }
  40. }

创建接口的实现类


   
  1. import java.util.Comparator;
  2. /**
  3. * 单独写的比较器,实现Compartor接口
  4. */
  5. public class StaffComparator implements Comparator<Staff> {
  6. //不一定要自然排序即升序,可以反过来写成降序
  7. @Override
  8. public int compare(Staff o1, Staff o2) {
  9. //降序
  10. /*if(o1.getSalary()>o2.getSalary()){
  11. return -1;
  12. }
  13. if(o1.getSalary()<o2.getSalary()){
  14. return 1;
  15. }
  16. return 0;*/
  17. //升序
  18. /*if(o1.getSalary()>o2.getSalary()){
  19. return 1;
  20. }
  21. if(o1.getSalary()<o2.getSalary()){
  22. return -1;
  23. }
  24. return 0;*/
  25. //先按照年龄倒序排,如果年龄相等比较工资
  26. if(o1.getAge()>o2.getAge()){
  27. return -1;
  28. }
  29. if(o1.getAge()<o2.getAge()){
  30. return 1;
  31. }
  32. //能到这里说明年龄相等,继续比较工资
  33. if(o1.getSalary()>o2.getSalary()){
  34. return 1;
  35. }
  36. if(o1.getSalary()<o2.getSalary()){
  37. return -1;
  38. }
  39. return 0;
  40. }
  41. }

测试方法:


   
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. public class TestComparator {
  6. public static void main(String[] args) {
  7. //测试Comparator接口
  8. Staff p1=new Staff("clyang",18,4000);
  9. Staff p2=new Staff("messi",30,8000);
  10. Staff p3=new Staff("ronald",32,9000);
  11. Staff p4=new Staff("herry",18,7600);
  12. Staff p5=new Staff("roben",35,7900);
  13. //添加到集合
  14. List<Staff> list=new ArrayList<>();
  15. list.add(p1);
  16. list.add(p2);
  17. list.add(p3);
  18. list.add(p4);
  19. list.add(p5);
  20. System.out.println("-----------------排序前-----------------");
  21. for (Staff staff : list) {
  22. System.out.println(staff);
  23. }
  24. //排序,需要使用自定义比较类
  25. Comparator myComparator=new StaffComparator();
  26. Collections.sort(list,myComparator);
  27. System.out.println("-----------------排序后-----------------");
  28. for (Staff staff : list) {
  29. System.out.println(staff);
  30. }
  31. }
  32. }

总结

两种接口的最主要区别还是一个对象自己实现和后期实现的区别。

文章来源: blog.csdn.net,作者:经典鸡翅,版权归原作者所有,如需转载,请联系作者。

原文链接:blog.csdn.net/hanqing456/article/details/111878962

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。