比较器

比较器（重点）
在之前接触了Arrays类,观察在Arrays类之中的一个方法：对象数组排序：public static void sort(Object[] a)
package classku;
import java.util.Arrays;
class Person{
private String name;
private int age;
public Person(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Per [name=" + name + ", age=" + age + "]";
}
}
public class Arraysb {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person per[]= new Person[]{
new Person("张三",18),new Person("李四",20),new Person("王五",45)
};
Arrays.sort(per);//排序
for(int x=0;x<per.length;x++) {
System.out.println(per[x]);
}
}


}
异常信息//Thread [main] (Suspended (exception ClassCastException))
现在发现此时需要让Persona类实现Comparable接口，而这就是一个比较器

Comparable接口(核心)

java.lang.Comparable接口是一个最为常用的比较器，接口定义如下
定义：public interface Comparable<T>{
public int compareTo(T o);
}
在Comparable接口之中发现只有一个compareTo（）方法，而此方法可以返回三种类型的数据：-1（小），0（等），1（大）
在之前String类的时候也学习过compareTo（）方法，当时的方法是可以进行大小判断的
范例：使用比较器
package classku;
import java.util.Arrays;
class Persona implements Comparable<Persona>{
private String name;
private int age;
public Persona(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Per [name=" + name + ", age=" + age + "]";
}
public int compareTo(Persona o) {
if(this.age<o.age) {
return 1;
}
else if(this.age>o.age) {
return -1;
}
return 0;
}
}
public class Arraysb {


public static void main(String[] args) {
// TODO Auto-generated method stub
Persona per[]= new Persona[]{
new Persona("张三",18),new Persona("李四",20),new Persona("王五",45)
};
Arrays.sort(per);//排序
for(int x=0;x<per.length;x++) {
System.out.println(per[x]);
}
}


}
以后只要是一组对象的大小比较一定使用Comparable接口


Binary Tree（理解）
既然已经知道对象之间的大小比较操作，那么就可以利用此概念实现二叉树开发，二叉树的基本原则如下
一个节点下可以保存两个节点：分别称为左子树和右子树；
取第一个数据作为根节点，比根节点小的树要放在左子树上，比根节点大的数据要放在右子树上
在进行输出的时候按照中序遍历（左，中，右）
范例：下面将利用Comparable实现二叉树操作
大小关系利用Comparable接口的compareTo()方法
范例：
package classku;
class Personb implements Comparable<Personb>{
private String name;
private int age;
public Personb(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Per [name=" + name + ", age=" + age + "]";
}
public int compareTo(Personb o) {
if(this.age>o.age) {
return 1;
}
else if(this.age<o.age) {
return -1;
}
return 0;
}
}
class BinaryTree {
private class Node{//一定要存在节点类
private Comparable data; //必须排序的是Comparable接口对象
private Node left;//左子树
private Node right;//右子树
public Node(Comparable data) {
this.data=data;
}
public void addNode(Node newNode) {
if(this.data.compareTo(newNode.data)<0) {
if(this.left==null) {
this.left=newNode;
}else {
this.left.addNode(newNode);
}
}else {
if(this.right==null) {
this.right=newNode;
}else {
this.right.addNode(newNode);
}
}
}
public void toArrayNode() {
if(this.left!=null){//有左子树
this.left.toArrayNode();
}
BinaryTree.this.retData[BinaryTree.this.foot++]=this.data;
if(this.right!=null) {
this.right.toArrayNode();
}
}
}
//=====================================
private Node root;//根节点
private int count;//统计对象的保存个数
private int foot;//操作脚标
private Object[] retData;
public void add(Comparable data) {
if(data==null) {
return ;
}
Node newNode=new Node(data);//将新的数据变为一个节点
if(this.root==null) {//根节点没有数据
this.root=newNode; //新的节点作为根节点存在
}else {//要保存在合适的节点中
this.root.addNode(newNode);
}
this.count++;//保存个数加一
}
public Object[] toArray() {
if(this.root==null) {
return null;
}
this.foot=0;
this.retData=new Object[this.count];//以保存大小开辟数组
this.root.toArrayNode();
return this.retData;
}
}
public class BinaryTreeDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
BinaryTree bt=new BinaryTree();
bt.add(new Personb("张三",20));
bt.add(new Personb("李四",18));
bt.add(new Personb("王五",25));
Object[] data=bt.toArray();
for(int x=0;x<data.length;x++) {
System.out.println(data[x]);
}
}


}

挽救的比较器：Comparator(了解)

在工作之中如果使用到比较器，首选是Comparable，当时Comparable有一个特点，它必须在一个类定义的时候就实现好接口，如果有这样一种情况，一个类已经开发完成了，并且此类不允许做出任何修改，此类在先设计的时候没有考虑到对象数组排序问题，后期又要提出此问题。
此时代码不能变更了，那么这个时候如何排序昵？
范例：开发的类
class Personc {
private String name;
private int age;
public Personc(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Per [name=" + name + ", age=" + age + "]";
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
Personb类已经开发完成，当时后来需要进行对象数组排序，那么这个时候由于Personb类无法修改了，那么只能够采用了另外一种比较器：java.util.Comparator接口
定义：public interface Comparator<T>{
public int compare(T o1,T o2);
public boolean equals(Object obj);
}
范例：定义专门的比较规则
class PersoncComparator implements Comparator<Personc>{
public int compare(Personc o1,Personc o2){
if(o1.getAge()>o2.getAge()){
return 1;
}else if(o1.getAge()<o2.getAge()){
return -1;
}
return 0;
}
}

此类只能够为Personb类服务，，随后如果要排序的时候在Arrays类有如下一个方法：

排序：public static<T> void sort(T[] a,Comparator<? super T> c)

public class BinaryTreeDemoa {
public static void main(String[] args) {
// TODO Auto-generated method stub
Personc per[]=new Personc[]{
new Personc("张三",20),
new Personc("李四",18),
new Personc("王五",25)
};
Arrays.sort(per, new PersoncComparator());//排序
for(int x=0;x<per.length;x++) {
System.out.println(per[x]);
}
}
}
请解释：这两种比较器的区别？
如果对象数组要进行排序，则需要使用到比较器，java提供有两种比较器：Comparable,Comparator
java.lang.Comparable是在一个类定义的时候实现的接口，里面有一个CompareTo()方法；
java.util.Comparator是一个挽救的比较器接口，需要单独为需要比较的类定义一个新的比较规则类，里面有两个方法：compare(),equals()