java学习笔记13--比较器(Comparable、Comparator)

2023-08-02 16:50:16

java学习笔记13--比较器(Comparable、Comparator)

分类： JAVA 2013-05-20 23:20 3296人阅读 评论(0) 收藏 举报

Comparable接口的作用

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

Comparable接口

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

Comparable接口的定义如下：

public  interface  Comparable<T>{

        public  int compareTo(T  o);

}

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

1：表示大于

-1：表示小于

0：表示相等

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

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

分析比较器的排序原理

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

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

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

另一种比较器：Compartor

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

public  interface  Comparator<T>{

public  int  compare(T o1，T o2);

boolean  equals(Object  obj);

}

MyComparator.java

  1. package com.itmyhome;
  2. import java.util.Comparator;
  3. public class MyComparator implements Comparator<Student> {  //实现比较器
  4. @Override
  5. public int compare(Student stu1, Student stu2) {
  6. // TODO Auto-generated method stub
  7. if(stu1.getAge()>stu2.getAge()){
  8. return 1;
  9. }else if(stu1.getAge()<stu2.getAge()){
  10. return -1;
  11. }else{
  12. return 0;
  13. }
  14. }
  15. }
  1. package com.itmyhome;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.Collections;
  5. import java.util.List;
  6. class Student {
  7. private String name;
  8. private int age;
  9. public Student(String name,int age ){
  10. this.name = name;
  11. this.age = age;
  12. }
  13. public String toString(){
  14. return "姓名："+this.name+", 年龄："+this.age;
  15. }
  16. public String getName() {
  17. return name;
  18. }
  19. public void setName(String name) {
  20. this.name = name;
  21. }
  22. public int getAge() {
  23. return age;
  24. }
  25. public void setAge(int age) {
  26. this.age = age;
  27. }
  28. }
  29. public class T {
  30. public static void main(String[] args) throws Exception{
  31. Student stu[] = {new Student("张三",23)
  32. ,new Student("李四",26)
  33. ,new Student("王五",22)};
  34. Arrays.sort(stu,new MyComparator());             //对象数组进行排序操作
  35. List<Student> list = new ArrayList<Student>();
  36. list.add(new Student("zhangsan",31));
  37. list.add(new Student("lisi",30));
  38. list.add(new Student("wangwu",35));
  39. Collections.sort(list,new MyComparator());      //List集合进行排序操作
  40. for (int i = 0; i < stu.length; i++) {
  41. Student s = stu[i];
  42. System.out.println(s);
  43. }
  44. System.out.println("*********");
  45. for (int i=0;i<list.size();i++){
  46. Student s = list.get(i);
  47. System.out.println(s);
  48. }
  49. }
  50. }
上一篇：js判断display隐藏显示


下一篇：PowerShell 启动应用程序【转】