Java学习提要——Comparable接口

1.Compatable接口

先看下Arrays类中提供的数组排序办法：
public static void sort(Object [] a)

//此程序会错误输出
import java.util.Arrays ;
class Book {
    private String title ;
    private double price ;
    public Book(String title,double price) {
        this.title = title ;
        this.price = price ;
    }
    public String toString() {
        return "book's name :" + this.title + ",book's price :" + this.price ; 
    }
}

public class Nice {
    public static void main(String args[]) throws Exception{
        Book books[] = new Book[] {
            new Book("java",49.9) ,
            new Book("jsp",54) ,
            new Book("asp",31) 
        };
        Arrays.sort(books) ;  //对象数组排序
        System.out.println(Arrays.toString(books));
    }
}
//原因在于，两个没有关系的类对象发生了强制性的转换

//观察Comparable接口定义
public interface Comparable<T> {
    public int compareTo(T o) ;
}

//compareTo()方法返回三类数据：1(大于)、0(等于)、-1(小于)
import java.util.Arrays ;
class Book implements Comparable<Book> {  //实现比较
    private String title ;
    private double price ;
    public Book(String title,double price) {
        this.title = title ;
        this.price = price ;
    }
    public int compareTo(Book o) {  //Arrays.sort()会自动调用此方法
        if(this.price > o.price) {  //大于小于可以互换return值，使书价格反过来输出
            return 1;  
        }else if(this.price < o.price) {
            return -1;
        }else {
            return 0;
        }
    }
    public String toString() {
        return "\n"+ "book's name: " + this.title + ",book's price: " + this.price + "\n"; 
    }
}

public class Nice {
    public static void main(String args[]) throws Exception{
        Book books[] = new Book[] {
            new Book("java",49.9) ,
            new Book("jsp",54) ,
            new Book("asp",31) 
        };
        Arrays.sort(books) ;  //对象数组排序,自动调用Arrays.sort()
        System.out.println(Arrays.toString(books));
    }
}

！以后只要是一组对象排序，对象所在的类一定要实现Comparable接口

2.Comparable与Comparator的区别

(即两种比较器的区别？)

1.如果对象数组要进行排序那么必须设置排序规则，
可以使用Comparable或Comparator接口实现

2.java.lang.Comparable是在一个类定义的时候实现好的接口，这样对本类的对象数组就可以进行排序，
在Comparable接口下定义有一个public int compareTo()方法

3.java.util.Comparable是一个专门定义一个指定类的比较规则，属于挽救的比较操作，里面有两个方法：
public int compare()、
public boolean equals()

3.Comparable接口实现二叉树

树的操作原理：选择第一个数据作为根节点，而后比根节点小的放在根节点的左子树(左节点)，比根节点大的数据放在右子树(右节点)，取得的时候按照中序遍历的方式取出(左-中-右)

//例子还是按照上面写的例子展开
import java.util.Arrays ;
class Book implements Comparable<Book> {  //实现比较
    private String title ;
    private double price ;
    public Book(String title,double price) {
        this.title = title ;
        this.price = price ;
    }
    public int compareTo(Book o) {  //Arrays.sort()会自动调用此方法
        if(this.price > o.price) {
            return 1;
        }else if(this.price < o.price) {
            return -1;
        }else {
            return 0;
        }
    }
    public String toString() {
        return "\n"+ "book's name: " + this.title + ",book's price: " + this.price + "\n"; 
    }
}
//定义二叉树
@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 Object [] retData ;
    private int foot ;
    public void add(Object obj) {
        Comparable com = (Comparable) obj ;  //必须为Comparable才可以实现Node保存
        Node newNode = new Node(com) ; //创建新节点
        if(this.root == null) {  //现在不存在根节点
            this.root = newNode ;  //设置根节点
        } else {
            this.root.addNode(newNode) ;  //交给Node类处理
        }
        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 Nice {
    public static void main(String args[]) throws Exception{
        BinaryTree bt = new BinaryTree();
        bt.add(new Book("java",49.9)) ;
        bt.add(new Book("jsp",54)) ;
        bt.add(new Book("asp",31)) ;
        Object obj[] = bt.toArray() ;
        System.out.println(Arrays.toString(obj)) ;
    }
}
//这些那内容，java类库都有实现，这些代码只是提高程序员自己的素质而已