正文
菜鸡的Java笔记 comparator 比较器
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
1.数组操作类： Arrays
2.两种比较器的使用： Comparable Comparator
3.实现二叉树算法
content （内容）
1.数组操作类： Arrays
Arrays 类一早就开始使用了。最早使用的是它的排序操作，但是现在打开 Arrays 观察一下有那些方法
二分查找法： public static int binarySearch(数据类型[] a,数据类型 key)
数组比较： public static boolean equals(数据类型[] a,数据类型[] a2)
数组的填充： public static void fill(数据类型[] a,数据类型 val)
数组转换为String输出： public static String toString(数据类型[] a)
范例：二分查找
package cn.mysterious.study3;
import java.util.Arrays;
public class StudyComparator {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data [] = new int[]{1,29,93,44,55,666,7,788,99};
java.util.Arrays.sort(data);
System.out.println(Arrays.binarySearch(data, 7));
}
}
范例：数组比较
package cn.mysterious.study3;
import java.util.Arrays;
public class StudyComparator {
public static void main(String[] args) {
// TODO Auto-generated method stub
int dataA [] = new int[]{1,29,93,44,55,666,7,788,99};
int dataB [] = new int[]{1,29,93,44,55,666,7,788,99};
System.out.println(Arrays.equals(dataA, dataB));
}
}
范例：数组填充
package cn.mysterious.study3;
import java.util.Arrays;
public class StudyComparator {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data [] = new int[]{1,29,93,44,55,666,7,788,99};
Arrays.fill(data, 10);
System.out.println(Arrays.toString(data));
}
}
在 Arrays 类中几乎包含了所有可能使用到的数组相关操作 重要的是这些方法的原理因为面试题或面试上会问到
2.比较器： Comparable
在 Arrays 类中提供有一个方法： public static void sort(Object[] a)
此方法可以直接针对对象数组进行排序的操作
但是如果现在真的要进行对象数组的排序，并不是意味着直接调用次方法即可
如果直接调用就有可能出现如下的错误信息：
Exception in thread "main" java.lang.ClassCastException:
cn.mysterious.study3.Person cannot be cast to java.lang.Comparable
之所以造成这样的问题，是因为如果要想进行对象数组的排序，必须要解决数据大小关系的问题，然而对象无法区分出大小关系
那么为了解决这样的问题 java 会自动的在排序的时候将所有的对象强制转换为 Comparable 接口对象
也就是说如果要想实现对象数组的自动排序，那么对象所在的类一定要实现 Comparable 接口
public interface Comparable<T>｛
public int compareTo(T o)
｝
String 累中的 comparaTo() 方法本身就是覆写了 Comparable 接口中的 comparaTo() 方法,而如果说用户现在需要进行排序
实际上只需要返回三个内容即可：0，-1，1
范例：对象数组的排序实现
package cn.mysterious.study3; import java.util.Arrays;
class Person implements Comparable<Person>{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "姓名：" + this.name + "，年龄：" + this.age + "\n";
}
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
if (this.age > o.age) {
return 1;
}else if(this.age < o.age){
return -1;
}else {
return 0;
}
// 简化操作： return this.age - o.age;
}
}
public class StudyComparator { public static void main(String[] args) {
Person per[] = new Person[]{
new Person("小少爷",15),
new Person("大少爷",35),
new Person("二少爷",28),
};
Arrays.sort(per);
System.out.println(Arrays.toString(per));
} }
结论：以后不管何种情况下，只要是进行对象数组的排序，一定要使用 Comparable 接口完成
实现二叉树算法（ Binary Tree ,(简称：BT) ）
二叉树也好，链表也好，本质是一样的，目的就是为了保存数据，实现动态的对象数组
所有的数据结构都一定有一个前提：必须痛过节点来进行数据的包裹，目的：确定先后顺序
那么现在也对 Node 进行修改，让其可以保存对象（ Object Comparable ），但是现在每个节点上要保留有两个子节点：左子树，右子树
保存的原则：比根节点小的数据放在左子树，比根节点大于等于的数据保存的右子树
最后按照中序遍历（左-根-右）的方式可以取得内容，所以数据是排序后的结果
范例：实现基础的二叉树 StudyTwoForkTree
package cn.mysterious.study3;
import java.util.Arrays;
class Person implements Comparable<Person>{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "姓名：" + this.name + "，年龄：" + this.age + "\n";
}
@Override
public int compareTo(Person o) {
return this.age - o.age;
}
}
class BinaryTree{ // 二叉树的实现类
private class Node{ // 数据结构中必须有 Node 类，负责保存数据以及节点的关系匹配
@SuppressWarnings(value = "rawtypes")
private Comparable data;
private Node left;//比根节点小的内容
private Node rigth;//比根节点大或等于的内容
@SuppressWarnings("unused")
public Node( @SuppressWarnings("rawtypes") Comparable data){
this.data = data;
}
@SuppressWarnings("unchecked")
public void addNode(Node newNode) {
// TODO Auto-generated method stub
if (this.data.compareTo(newNode.data) > 0) { // 保存在左边
if (this.left == null) {
this.left = newNode;
}else {
this.left.addNode(newNode);
}
}else {
if (this.rigth == null) {
this.rigth = newNode;
} else {
this.rigth.addNode(newNode);
}
}
}
public void toArrayNode() {
// TODO Auto-generated method stub
if (this.left != null) {// 有左节点
this.left.toArrayNode();
}
BinaryTree.this.retData[BinaryTree.this.foot ++] = this.data;
if (this.rigth != null) {
this.rigth.toArrayNode();
}
}
}
//****** 编写 BinaryTree 的操作 ******
private Node root; //必须保留根节点
private int count = 0;
private int foot = 0;
private Object[] retData;
@SuppressWarnings("rawtypes")
public void add(Object obj) { //数据的追加
Comparable data = (Comparable)obj;
Node newNode = new Node(data);// 将数据包装在 Node 节点之中
if (this.root == null) {
this.root = newNode;
}else {
this.root.addNode(newNode);
}
this.count ++;
}
public Object[] toArray(){
if (this.count > 0) {
this.foot = 0;
this.retData = new Object[this.count];
this.root.toArrayNode();
return this.retData;
} else {
return null;
}
}
}
public class StudyTwoForkTree { public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
bt.add(new Person("小少爷",15));
bt.add(new Person("大少爷",35));
bt.add(new Person("二少爷",28));
System.out.println(Arrays.toString(bt.toArray()));
} }
如果想收入高一些的可以适当的把代码写的完善一些
比较器： Comparator
通过 Comparable 的观察可以发现，如果一个类的对象要想进行对象数组排序，那么这个类在定义的时候就必须明确的实现好 Comparable 接口
但是有没有这样一种可能性出现，一个类原本定义完成了，原本是没有排序要求的，可是后期却需要追加排序，并且这个类已经不能够修改了
那么在这种情况下，就可以利用另外一个接口完成排序： java.util.Comparator 接口
此接口定义如下：
@FunctionalInterface
public interface Comparator<T>｛
public int compare(T o1,T o2)
public boolean equals(Object obj)
｝
如果要想继续使用 Arrays 实现排序操作，那么就必须观察新的排序方法：
排序： public static <T> void sort(T[] a,Comparator<? super T> c)
范例：定义一个单独的 Person 类
class Person {
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "姓名：" + this.name + "，年龄：" + this.age + "\n";
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
}
前提： Person 类不允许发生改变
范例：实现单独的比较器
package cn.mysterious.study3;
import java.util.Comparator;
class Person {
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "姓名：" + this.name + "，年龄：" + this.age + "\n";
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
}
class PersonComparator implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
// TODO Auto-generated method stub
return o1.getAge() - o2.getAge();
}
}
public class ComparatorClass {
public static void main(String[] args) {
Person per[] = new Person[]{
new Person("小少爷",15),
new Person("大少爷",35),
new Person("二少爷",28),
};
Arrays.sort(per,new PersonComparator()); // 编写排序
System.out.println(Arrays.toString(per));
}
}
面试题：请解释两种比较器的区别？
在进行对象数组排序的过程之中需要使用到比较器，比较器有两个： Comparator Comparable
java.util.Comparable ：是在类定义的时候默认实现好的接口。里面提供有一个 comparaTo() 方法用于比较大小
java.util.Comparator ：需要单独定义一个排序的比较规则类，里面有两个方法： compare(),equals()
总结
以后如果开发中考虑到排序的需求，优先考虑使用 Comparable 接口，不到万不得已不要使用 Comparator
