一篇文章带你学会 Java 中的 Comparable 接口- JAVA

文章目录

- 一、比较器的基本应用
- 二、分析比较器的排序原理

一、比较器的基本应用

使用 java.util.Arrays 类进行数组排序操作时，对象所在的类必须实现 Comparable 接口，这个接口就是用于指定对象排序规则的
在这里插入图片描述
因为这里本身就是用泛型定义的，所以子类继承需要指定子类类型

Comparable 接口的定义如下：

public interface Comparable<T>{
	public int compareTo(T o)
}

这里接口中只有一个 compareTo 方法，该方法返回一个 int 类型的数据，但是此 int 的值只能是一下3种：

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

例如此时设计一个学生类，包含姓名、年龄、成绩，并产生一个对象数组，要求按成绩由高到底排序，如果成绩相等，则按年龄由低到高排序。
此时如果直接编写排序操作会比较麻烦，所以可以==使用 Arrays 类中的 sort() 方法进行排序操作。

import java.util.Arrays;

class Student implements Comparable<Student>{//指定类型为 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" + age + "\t\t" + score;
    }
    public int compareTo(Student stu){
        //覆写 compareTo() 方法，实现排序规则的应用
        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 Root{
    public static void main(String[] args) {
        Student[] stu = {new Student("stu1",20,90.0f),
        new Student("stu2",22,90.0f),
        new Student("stu3",20,70.0f),
        new Student("stu4",34,98)};
        Arrays.sort(stu);
        for (Student x:stu){
            System.out.println(x);
        }
    }
}
45
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

在这里插入图片描述

二、分析比较器的排序原理

这里排序过程实际上就是数据结构中的二叉树排序方法，通过二叉树进行排序，然后利用中序遍历的方式把内容依次读取出来。

二叉树的排序原理：

将第一个内容作为根节点保存，如果后面的值比根节点的值小，则放在根节点的左子树，如果后面的值比根节点的值大，则放在根节点的右子树。

在这里插入图片描述

class BinaryTree{
    class Node{//声明一个节点类
        private Comparable data;//保存具体的内容
        private Node left;
        private Node right;
        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();//每传入一个新的内容就声明一个根节点
        newNode.data = data;
        if(root == null){
            root = newNode;//如果是第1个元素，设置成根元素
        }else{
            root.addNode(newNode);//确定节点是放在左子树还是右子树
        }
    }
    public void print(){//输出节点
        this.root.printNode();
    }
}
public class Test{
    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();
    }
}
45
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61