java常用类——比较器

本节目标：

    1.掌握Comparable比较接口的使用

    2.了解比较器的基本排序原理

    3.掌握Comparator比较接口的使用

Comparable接口

public interface Comparable<T>{

    public int compareTo(T o);

}

此方法返回一个int类型的数据：

1：表示大于；

-1：表示小于；

0：表示等于

public 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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score+ "]";
}
@Override
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 ComparableDemo {
public static void main(String[] args) {
Student[] stu = {new Student("张三",24,82.9f),new Student("李四",24,90.5f),
new Student("赵四",23,93f),new Student("王五",26,90.5f),};
Arrays.sort(stu);
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i]);
}
}

}

运行结果：

Student [name=赵四, age=23, score=93.0]
Student [name=李四, age=24, score=90.5]
Student [name=王五, age=26, score=90.5]

Student [name=张三, age=24, score=82.9]

比较器的排序原理：

排序过程实际上是利用了二叉树的排序方法，通过二叉树排序后，利用中序遍历的方式依次读取出来。

将第一个内容作为根节点保存，后边的值与根节点进行比较，如果比根节点小，则放在根节点的左子树，否则放在右子树，依次进行递归操作。如图所示：

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();
}
}
};
class BinaryTree {
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();
}
}

运行结果：

排序之后的结果：
1 3 3 5 5 8 9 10

Comparator接口

如果一个类在建立初期没有实现Comparable接口，此时是无法进行对象排序的，为了解决这样的问题，可以使用Comparator接口。

public interface Comparator<T>{

    public int compare(T t1,T t2);

    boolean equals(Object obj);

}

定义一个实体类：

public class Student{
private String name;
private int age;
private float score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}

@Override
public boolean equals(Object obj) {
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;
}
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score+ "]";
}

}

单独建立一个排序规则类：

class StuComparator implements Comparator<Student> {
//因为Object类中本身已有equals方法，不用覆写
@Override
public int compare(Student o1, Student o2) {
if (o1.equals(o2)) {
return 0;
}
if (o1.getAge() < o2.getAge()) {//按年龄比较，由大到小
return 1;
} else {
return -1;
}
}
};
public class StuComparatorDemo {
public static void main(String[] args) {
Student[] stu = {new Student("张三",24,82.9f),new Student("李四",24,90.5f),
new Student("赵四",23,93f),new Student("王五",26,90.5f),};
Arrays.sort(stu,new StuComparator());
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i]);
}
}
}

运行结果：

Student [name=王五, age=26, score=90.5]
Student [name=李四, age=24, score=90.5]
Student [name=张三, age=24, score=82.9]
Student [name=赵四, age=23, score=93.0]

总结：

在使用中，尽可能使用Comparable接口，在需要排序的类中实现好此接口。

Comparator需要另外建立一个排序的类，如果用来排序的规则类就会很多，操作起来会比较麻烦。

只要是对象排序，在java中以Comparable为准!!!