Java-比较器(Comparable、Comparator)

2024-08-27 10:32
文章标签 java 比较 comparator comparable

本文主要是介绍Java-比较器(Comparable、Comparator)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

原文：http://blog.csdn.net/itmyhome1990/article/details/8952722

Comparable接口的作用

之前Arrays类中存在sort()方法，此方法可以直接对对象数组进行排序。

 

Comparable接口

可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口。

Comparable接口的定义如下：

public  interface  Comparable<T>{

        public  int compareTo(T  o);

}

此方法返回一个int类型的数据，但是此int的值只能是一下三种：

1：表示大于

-1：表示小于

0：表示相等

 

要求：定义一个学生类，里面有姓名，年龄，成绩三个属性，要求按成绩由高到低排序，如果成绩相等，则按照年龄由低到高排序。

[java] view plain copy
  1. package com.itmyhome;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. class Student implements Comparable<Student>{  
  6.     private String name;  
  7.     private int age;  
  8.     private float score;  
  9.       
  10.     public Student(String name,int age,float score){  
  11.         this.name = name;  
  12.         this.age = age;  
  13.         this.score = score;  
  14.     }  
  15.       
  16.     @Override  
  17.     public int compareTo(Student stu) {  //覆写compareTo方法实现排序规则的应用  
  18.         if(this.score>stu.score){  
  19.             return -1;  
  20.         }else if(this.score<stu.score){  
  21.             return 1;  
  22.         }else{  
  23.             if(this.age>stu.age){  
  24.                 return 1;  
  25.             }else if(this.age<stu.age){  
  26.                 return -1;  
  27.             }else{  
  28.                 return 0;  
  29.             }  
  30.         }  
  31.     }  
  32.       
  33.     public String toString(){  
  34.         return "姓名："+this.name+", 年龄："+this.age+", 成绩："+this.score;  
  35.     }  
  36.       
  37.     public String getName() {  
  38.         return name;  
  39.     }  
  40.     public void setName(String name) {  
  41.         this.name = name;  
  42.     }  
  43.     public int getAge() {  
  44.         return age;  
  45.     }  
  46.     public void setAge(int age) {  
  47.         this.age = age;  
  48.     }  
  49.     public float getScore() {  
  50.         return score;  
  51.     }  
  52.     public void setScore(float score) {  
  53.         this.score = score;  
  54.     }  
  55.       
  56.       
  57. }  
  58.   
  59. public class T {  
  60.     public static void main(String[] args) throws Exception{  
  61.         Student stu[] = {new Student("张三",22,80f)  
  62.                         ,new Student("李四",23,83f)  
  63.                         ,new Student("王五",21,80f)};  
  64.           
  65.         Arrays.sort(stu);   //进行排序操作  
  66.         for (int i = 0; i < stu.length; i++) {  
  67.             Student s = stu[i];  
  68.             System.out.println(s);  
  69.         }  
  70.     }  
  71. }  


分析比较器的排序原理

实际上比较器的操作，就是经常听到的二叉树的排序算法。

排序的基本原理：使用第一个元素作为根节点，之后如果后面的内容比根节点小，则放在左子树，如果内容比根节点的内容要大，则放在右子树。

[java] view plain copy
  1. package com.itmyhome;  
  2.   
  3. class BinaryTree {  
  4.     class Node { // 声明一个节点类  
  5.         private Comparable data; // 保存具体的内容  
  6.         private Node left; // 保存左子树  
  7.         private Node right; // 保存右子树  
  8.   
  9.         public Node(Comparable data) {  
  10.             this.data = data;  
  11.         }  
  12.   
  13.         public void addNode(Node newNode) {  
  14.             // 确定是放在左子树还是右子树  
  15.             if (newNode.data.compareTo(this.data) < 0) { // 内容小，放在左子树  
  16.                 if (this.left == null) {  
  17.                     this.left = newNode; // 直接将新的节点设置成左子树  
  18.                 } else {  
  19.                     this.left.addNode(newNode); // 继续向下判断  
  20.                 }  
  21.             }  
  22.             if (newNode.data.compareTo(this.data) >= 0) { // 放在右子树  
  23.                 if (this.right == null) {  
  24.                     this.right = newNode; // 没有右子树则将此节点设置成右子树  
  25.                 } else {  
  26.                     this.right.addNode(newNode); // 继续向下判断  
  27.                 }  
  28.             }  
  29.         }  
  30.   
  31.         public void printNode() { // 输出的时候采用中序遍历  
  32.             if (this.left != null) {  
  33.                 this.left.printNode(); // 输出左子树  
  34.             }  
  35.             System.out.print(this.data + "\t");  
  36.             if (this.right != null) {  
  37.                 this.right.printNode();  
  38.             }  
  39.         }  
  40.     };  
  41.   
  42.     private Node root; // 根元素  
  43.   
  44.     public void add(Comparable data) { // 加入元素  
  45.         Node newNode = new Node(data); // 定义新的节点  
  46.         if (root == null) { // 没有根节点  
  47.             root = newNode; // 第一个元素作为根节点  
  48.         } else {  
  49.             root.addNode(newNode); // 确定是放在左子树还是放在右子树  
  50.         }  
  51.     }  
  52.   
  53.     public void print() {  
  54.         this.root.printNode(); // 通过根节点输出  
  55.     }  
  56. };  
  57.   
  58. public class T2 {  
  59.     public static void main(String args[]) {  
  60.         BinaryTree bt = new BinaryTree();  
  61.         bt.add(8);  
  62.         bt.add(3);  
  63.         bt.add(3);  
  64.         bt.add(10);  
  65.         bt.add(9);  
  66.         bt.add(1);  
  67.         bt.add(5);  
  68.         bt.add(5);  
  69.         System.out.println("排序之后的结果：");  
  70.         bt.print();  
  71.     }  
  72. };  


 

另一种比较器：Compartor

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这一的问题，java又定义了另一个比较器的操作接口 Comparator 此接口定义在java.util包中，接口定义如下：

public  interface  Comparator<T>{

                 public  int  compare(T o1，T o2);

                 boolean  equals(Object  obj);

}

MyComparator.java

[java] view plain copy
  1. package com.itmyhome;  
  2.   
  3. import java.util.Comparator;  
  4.   
  5. public class MyComparator implements Comparator<Student> {  //实现比较器  
  6.   
  7.     @Override  
  8.     public int compare(Student stu1, Student stu2) {  
  9.         // TODO Auto-generated method stub  
  10.         if(stu1.getAge()>stu2.getAge()){  
  11.             return 1;  
  12.         }else if(stu1.getAge()<stu2.getAge()){  
  13.             return -1;  
  14.         }else{  
  15.             return 0;  
  16.         }  
  17.     }  
  18.   
  19. }  


 

[java] view plain copy
  1. package com.itmyhome;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.Collections;  
  6. import java.util.List;  
  7.   
  8. class Student {  
  9.     private String name;  
  10.     private int age;  
  11.       
  12.     public Student(String name,int age ){  
  13.         this.name = name;  
  14.         this.age = age;  
  15.     }  
  16.       
  17.     public String toString(){  
  18.         return "姓名："+this.name+", 年龄："+this.age;  
  19.     }  
  20.       
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.     public void setName(String name) {  
  25.         this.name = name;  
  26.     }  
  27.     public int getAge() {  
  28.         return age;  
  29.     }  
  30.     public void setAge(int age) {  
  31.         this.age = age;  
  32.     }  
  33. }  
  34.   
  35. public class T {  
  36.     public static void main(String[] args) throws Exception{  
  37.         Student stu[] = {new Student("张三",23)  
  38.                         ,new Student("李四",26)  
  39.                         ,new Student("王五",22)};  
  40.         Arrays.sort(stu,new MyComparator());             //对象数组进行排序操作  
  41.           
  42.         List<Student> list = new ArrayList<Student>();  
  43.         list.add(new Student("zhangsan",31));  
  44.         list.add(new Student("lisi",30));  
  45.         list.add(new Student("wangwu",35));  
  46.         Collections.sort(list,new MyComparator());      //List集合进行排序操作  
  47.           
  48.         for (int i = 0; i < stu.length; i++) {  
  49.             Student s = stu[i];  
  50.             System.out.println(s);  
  51.         }  
  52.           
  53.         System.out.println("*********");  
  54.           
  55.         for (int i=0;i<list.size();i++){  
  56.             Student s = list.get(i);  
  57.             System.out.println(s);  
  58.         }  
  59.     }  
  60. }  

这篇关于Java-比较器(Comparable、Comparator)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1111417。

相关文章

java如何解压zip压缩包

java如何解压zip压缩包

《java如何解压zip压缩包》：本文主要介绍java如何解压zip压缩包问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Java解压zip压缩包实例代码结果如下总结java解压zip压缩包坐在旁边的小伙伴问我怎么用 java 将服务器上的压缩文件解压出来，
阅读更多...
SpringBoot中SM2公钥加密、私钥解密的实现示例详解

SpringBoot中SM2公钥加密、私钥解密的实现示例详解

《SpringBoot中SM2公钥加密、私钥解密的实现示例详解》本文介绍了如何在SpringBoot项目中实现SM2公钥加密和私钥解密的功能,通过使用Hutool库和BouncyCastle依赖,简化... 目录一、前言1、加密信息(示例)2、加密结果(示例)二、实现代码1、yml文件配置2、创建SM2工具
阅读更多...
Spring WebFlux 与 WebClient 使用指南及最佳实践

Spring WebFlux 与 WebClient 使用指南及最佳实践

《SpringWebFlux与WebClient使用指南及最佳实践》WebClient是SpringWebFlux模块提供的非阻塞、响应式HTTP客户端,基于ProjectReactor实现,... 目录Spring WebFlux 与 WebClient 使用指南1. WebClient 概述2. 核心依
阅读更多...
Spring Boot @RestControllerAdvice全局异常处理最佳实践

Spring Boot @RestControllerAdvice全局异常处理最佳实践

《SpringBoot@RestControllerAdvice全局异常处理最佳实践》本文详解SpringBoot中通过@RestControllerAdvice实现全局异常处理,强调代码复用、统... 目录前言一、为什么要使用全局异常处理？二、核心注解解析1. @RestControllerAdvice2
阅读更多...
Spring IoC 容器的使用详解(最新整理)

Spring IoC 容器的使用详解(最新整理)

《SpringIoC容器的使用详解(最新整理)》文章介绍了Spring框架中的应用分层思想与IoC容器原理,通过分层解耦业务逻辑、数据访问等模块,IoC容器利用@Component注解管理Bean... 目录1. 应用分层2. IoC 的介绍3. IoC 容器的使用3.1. bean 的存储3.2. 方法注
阅读更多...
Spring事务传播机制最佳实践

Spring事务传播机制最佳实践

《Spring事务传播机制最佳实践》Spring的事务传播机制为我们提供了优雅的解决方案,本文将带您深入理解这一机制,掌握不同场景下的最佳实践,感兴趣的朋友一起看看吧... 目录1. 什么是事务传播行为2. Spring支持的七种事务传播行为2.1 REQUIRED（默认）2.2 SUPPORTS2
阅读更多...
C# 比较两个list 之间元素差异的常用方法

C# 比较两个list 之间元素差异的常用方法

《C#比较两个list之间元素差异的常用方法》：本文主要介绍C#比较两个list之间元素差异,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录1. 使用Except方法2. 使用Except的逆操作3. 使用LINQ的Join,GroupJoin
阅读更多...
怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
Java进程异常故障定位及排查过程

Java进程异常故障定位及排查过程

《Java进程异常故障定位及排查过程》：本文主要介绍Java进程异常故障定位及排查过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、故障发现与初步判断1. 监控系统告警2. 日志初步分析二、核心排查工具与步骤1. 进程状态检查2. CPU 飙升问题3. 内存
阅读更多...
java中新生代和老生代的关系说明

java中新生代和老生代的关系说明

《java中新生代和老生代的关系说明》：本文主要介绍java中新生代和老生代的关系说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、内存区域划分新生代老年代二、对象生命周期与晋升流程三、新生代与老年代的协作机制1. 跨代引用处理2. 动态年龄判定3. 空间分
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2