java常用类——比较器

浅浅的花香味﹌ 2022-05-27 00:21 210阅读 0赞

本节目标：

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\]

# 比较器的排序原理： #

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

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

![2018040818505722][]

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();  
\}  
\}

运行结果：

排序之后的结果：  
133558910

# 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为准!!!**

[2018040818505722]: /images/20220527/8f39658ca74a4c80adf99bd73a47ee90.png