【Java常用类库】_比较器（Comparable、Comparator）笔记

来源：互联网发布：手机淘宝秒杀怎么刷新编辑：程序博客网时间：2024/05/17 05:58

【Java常用类库】_比较器（Comparable、Comparator）笔记

分类： Java

【Java常用类库】_比较器（Comparable、Comparator）笔记

本章目标：
掌握Comparable比较接口的使用
了解比较器的基本排序原理
掌握Comparator比较接口的使用

Comparable接口

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

Comparable接口定义类如下：

public interface Comparable<T>{
public int compareTo(T o);
}
此方法返回一个int类型的数据，但是此int的值只能是以下三种：

1：表示大于
-1：表示小于
0：表示相等

实例代码：

[java] view plaincopyprint?
class Student implements Comparable<Student>{  
    private String name;  
    private int age;  
    private float score;  
    public Student(String name,int age,float score){  
        this.name = name;  
        this.age = age;  
        this.score = score;  
    }  
    public String toString(){  
        return name+"\t\t"+this.age+"\t\t"+this.score;  
    }  
    public int compareTo(Student stu){  
        if(this.score>stu.score){  
            return -1;  
        }else if(this.score<stu.score){  
            return 1;  
        }else{  
            if(this.age>stu.age){  
                return 1;  
            }else if(this.age<stu.age){  
                return -1;  
            }else{  
                return 0;  
            }  
        }  
    }  
}  
public class ComparableDemo01{  
    public static void main(String args[]){  
        Student stu[] = {new Student("张三",20,99.0f),new Student("李四",22,90.0f),new Student("王五",22,100.0f)};  
        java.util.Arrays.sort(stu);    //进行排序操作  
        for(int i=0;i<stu.length;i++){    //循环输出数组内容  
            System.out.println(stu[i]);  
        }  
    }  
}  

注意：如果在此时Student类中没有实现Comparable接口，则在执行时会出现以下的异常。

Exception in thread "main" java.lang.ClassCastException:

3.2、分析比较器的排序原理:

实际上之前所讲解的排序过程，也就是经常听到数据结构中的二叉树的排序方法，通过二叉树进行排序，之后利用中序遍历的方式把内容依次读取出来。

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。在遍历左、右子树时，仍然先遍历左子树，再访问根结点，最后遍历右子树。

下面就自己手工实现一个二叉树的比较算法。
为了操作方法，此处使用Integer类完成。

[java] view plaincopyprint?
public class ComparableDemo02{  
    public static void main(String args[]){  
        Comparable com = null ;            // 声明一个Comparable接口对象  
        com = 30 ;                        // 通过Integer为Comparable实例化  
        System.out.println("内容为：" + com) ;    // 调用的是toString()方法  
    }  
};  

了解了此特性之后，下面就可以动手完成一个二叉树算法。

[java] view plaincopyprint?
class BinaryTree{  
    class Node{            // 声明一个节点类  
        private Comparable data ;    // 保存具体的内容  
        private Node left ;            // 保存左子树  
        private Node right ;        // 保存右子树  
        public Node(Comparable data){  
            this.data = data ;  
        }  
        public void addNode(Node newNode){  
            // 确定是放在左子树还是右子树  
            if(newNode.data.compareTo(this.data)<0){    // 内容小，放在左子树  
                if(this.left==null){  
                    this.left = newNode ;    // 直接将新的节点设置成左子树  
                }else{  
                    this.left.addNode(newNode) ;    // 继续向下判断  
                }  
            }  
            if(newNode.data.compareTo(this.data)>=0){    // 放在右子树  
                if(this.right==null){  
                    this.right = newNode ;    // 没有右子树则将此节点设置成右子树  
                }else{  
                    this.right.addNode(newNode) ;    // 继续向下判断  
                }  
            }  
        }  
        public void printNode(){    // 输出的时候采用中序遍历  
            if(this.left!=null){  
                this.left.printNode() ;    // 输出左子树  
            }  
            System.out.print(this.data + "\t") ;  
            if(this.right!=null){  
                this.right.printNode() ;  
            }  
        }  
    };  
    private Node root ;        // 根元素  
    public void add(Comparable data){    // 加入元素  
        Node newNode = new Node(data) ;    // 定义新的节点  
        if(root==null){    // 没有根节点  
            root = newNode ;    // 第一个元素作为根节点  
        }else{  
            root.addNode(newNode) ; // 确定是放在左子树还是放在右子树  
        }  
    }  
    public void print(){  
        this.root.printNode() ;    // 通过根节点输出  
    }  
};  
public class ComparableDemo03{  
    public static void main(String args[]){  
        BinaryTree bt = new BinaryTree() ;  
        bt.add(8) ;  
        bt.add(3) ;  
        bt.add(3) ;  
        bt.add(10) ;  
        bt.add(9) ;  
        bt.add(1) ;  
        bt.add(5) ;  
        bt.add(5) ;  
        System.out.println("排序之后的结果：") ;  
        bt.print() ;  
    }  
};  

3.3、另一种比较器：Comparator

直接贴出代码：

[java] view plaincopyprint?
import java.util.* ;  
class Student{    // 指定类型为Student  
    private String name ;  
    private int age ;  
    public Student(String name,int age){  
        this.name = name ;  
        this.age = age ;  
    }  
    public boolean equals(Object obj){    // 覆写equals方法  
        if(this==obj){  
            return true ;  
        }  
        if(!(obj instanceof Student)){  
            return false ;  
        }  
        Student stu = (Student) obj ;  
        if(stu.name.equals(this.name)&&stu.age==this.age){  
            return true ;  
        }else{  
            return false ;  
        }  
    }  
    public void setName(String name){  
        this.name = name ;  
    }  
    public void setAge(int age){  
        this.age = age ;  
    }  
    public String getName(){  
        return this.name ;  
    }  
    public int getAge(){  
        return this.age ;  
    }  
    public String toString(){  
        return name + "\t\t" + this.age  ;  
    }  
};  
  
class StudentComparator implements Comparator<Student>{    // 实现比较器  
    // 因为Object类中本身已经有了equals()方法  
    public int compare(Student s1,Student s2){  
        if(s1.equals(s2)){  
            return 0 ;  
        }else if(s1.getAge()<s2.getAge()){    // 按年龄比较  
            return 1 ;  
        }else{  
            return -1 ;  
        }  
    }  
};  
  
public class ComparatorDemo{  
    public static void main(String args[]){  
        Student stu[] = {new Student("张三",20),  
            new Student("李四",22),new Student("王五",20),  
            new Student("赵六",20),new Student("孙七",22)} ;  
        java.util.Arrays.sort(stu,new StudentComparator()) ;    // 进行排序操作  
        for(int i=0;i<stu.length;i++){    // 循环输出数组中的内容  
            System.out.println(stu[i]) ;  
        }  
    }  
};  

0 0