比较器

比较器(Comparable)

　　对于比较器首先给出一个明确的定义：基本上存在原理分析，而在实际开发中使用的意义不大

　　如果要想进行数组操作Arrays类可以提供很好的支持

　　对象数组排序：public static void sort(Object[] a);

　　对象要进行数组的实现，必须定义Comparable接口：

package cn.Tony.demo;
import java.util.Arrays;
class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]
";
    }
    @Override
    public int compareTo(Person o) {
        if(this.age>o.age) {
            return 1;//大于
        }else if(this.age<o.age){
            return -1;
        }else {
            return 0;
        }
    }
}
public class TestDemo {
    public static void main(String[] args) throws Exception {
        Person[] per=new Person[] {new Person("张三",20),
                new Person("李四",19),new Person("王五",21)};//对象数组
        Arrays.sort(per);
        System.out.println(Arrays.toString(per));
    }
}

　　要想实现对象数组的排序就要实现Comparable接口

二叉树

　　在之前学习过链表程序，链表程序的本质是在于节点的相互引用。但是之前的链表有一个 缺点，所有的保存数据的顺序就是你添加顺序无法排序，如果要想进行排序的保存，就可以通过树的结构完成，

　　树的结构：取第一个数据作为根节点，而后比这个根节点大的数据放在节点的右边，如果比根节点小的放在左子树 在进行输出的时候按照中序遍历的原则取出：左中右

　　树的结构实现就是大小的比较，可以用Comparable接口完成， 

范例：实现二叉树

package cn.Tony.demo;

import java.util.Arrays;

@SuppressWarnings("rawtypes")
class BinaryTree{    //现在实现一个二叉树
    private class Node{
        private Comparable data;//保存的操作数据，必须是Comparable子类并且要判断大小
        private Node left;//保存左边的节点
        private Node right;//保存右边节点
        @SuppressWarnings("unused")
        public Node(Comparable data) {
            this.data=data;
        }
        @SuppressWarnings("unchecked")
        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=0;//脚标    
    private Object[] retData;//返回数据
    public Object[] toArray() {
        this.foot=0;//脚标清零
        this.retData=new Object[this.count];
        this.root.toArrayNode();
        return this.retData;
    }
    public void add(Object data) {//可以保存任何数据
        if(data==null) {
            return ;
        }
        Node newNode=new Node((Comparable)data);
        if(this.root==null) {
            this.root=newNode;
        }else {
            this.root.addNode(newNode);
        }
        this.count++;
    }
}
public class TestDemo {
    public static void main(String[] args) throws Exception {
        BinaryTree bt=new BinaryTree();
        bt.add("B");
        bt.add("X");
        bt.add("A");
        System.out.println(Arrays.toString(bt.toArray()));
    }
}

　　如果要有兴趣可以继续将之前链表的功能在此处实现

挽救的比较器：Comparator（）

　　Comparator的核心价值在于：当一个类定义的时候就已经明确好了这个类的数据保存是需要排序的，但很多情况下，一个类的设计的时候可能没有考虑到排序的需要。

如果类中不允许修改想要进行排序需要使用java.util.Comparator

Comparable和Comparator的区别

　　java.lang.Comparable:是在一个类定义的时候默认实现好的接口，里面存在ComparaTo()方法

　　java.util.Comparator:是挽救的比较接口，需要单独的比较的规则类，里面有Comparator方法和equals方法。

以后分析还是Comparable的类