Java學習總結：37(比較器)

比較器

Arrays類

No.	方法	類型	描述
1	public static boolean equals(int [] a,int [] a2)	普通	判斷兩個數組是否相等，此方法被重載多次，可以判斷各種數據類型的數組
2	public static void fill(int [] a,int val)	普通	將指定內容填充到數組中，此方法被重載多次，可以填充各種數據類型的數組
3	public static void sort(int [] a)	普通	數組排序，此方法被重載多次，可以對各種數據類型的數組進行排序
4	public static int binarySearch(int [] a,int key)	普通	對排序後的數組進行檢索，此方法被重載多次，可以對各種數據類型的數組進行檢索
5	public static String toString(int [] a)	普通	輸出數組信息，此方法被重載多次，可以輸出各種數據類型的數組

Arrays類中的binarySearch()和sort()方法

例：查找數組內容

package Project.Study.ArrayClass;

import java.util.Arrays;

public class Test1 {
    public static void main(String[]args){
        int data[]=new int[]{1,5,6,7,2,4,3,9,8};
        java.util.Arrays.sort(data);			//數組必須排序纔可以查找
        System.out.println(Arrays.binarySearch(data,9));
    }
}
//結果：
//8(排序後的數據索引)

注：binarySearch()方法爲二分查找，使用前必須要對目標數組進行排序，如果數組沒有排序，則查詢到的結果是不確定的。

Arrays類中的equals()方法

例：數組相等比較

package Project.Study.ArraysClass;

import java.util.Arrays;

public class Test2 {
    public static void main(String[]args){
        int data1[]=new int[]{1,2,3,4,5};
        int data2[]=new int[]{1,2,3,4,5};
        int data3[]=new int[]{1,2,3};
        System.out.println(Arrays.equals(data1,data2));	//比較是否相等
        System.out.println(Arrays.equals(data1,data3));
    }
}
//結果：
//true
//false

注意：Arrays類中的equals()方法並不是Object類定義的equals()方法，只是借用了方法名稱。使用此方法時，必須保證數組中的數據內容的順序是一致的。

例：當數據內容順序不一致時

package Project.Study.ArraysClass;

import java.util.Arrays;

public class Test2 {
    public static void main(String[]args){
        int data1[]=new int[]{1,2,3,4,5};
        int data2[]=new int[]{1,2,3,5,4};
        int data3[]=new int[]{1,2,3};
        System.out.println(Arrays.equals(data1,data2));	//比較是否相等
        System.out.println(Arrays.equals(data1,data3));
    }
}
//結果：
//false
//false

Arrays類中的fill()方法

例：數組填充

package Project.Study.ArraysClass;

import java.util.Arrays;

public class Test3 {
    public static void main(String[]args){
        int data[]=new int[10];
        Arrays.fill(data,3);	//填充數組數據
        System.out.println(data);
        System.out.println(Arrays.toString(data));//將數組變爲字符串輸出
    }
}
//結果：
//[I@10f87f48
//[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

比較器：Comparable

上面我們說的排序只是針對普通數組的排序，而對象數組也可以用sort()方法進行排序(public static void sort(Object[]a))，前提是：對象所在的類一定要實現Comparable接口，否則就會出現ClassCastException異常。
該接口定義如下：

public interface Comparable<T>{
	public int compareTo(T o);
}

我們可以看到，Comparable接口中只定義了一個compareTo()方法，此方法返回一個int型數據，而用戶覆寫此方法時只需要返回3種結果：1、-1、0。

例：實現對象數組排序

package Project.Study.ComparableClass;

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;
    }
    @Override
    public String toString(){
        return "書名："+this.title+",價格："+this.price+"\n";
    }
    @Override
    public int compareTo(Book o){		//Arrays.sort()會自動調用此方法比較
        return Double.compare(this.price, o.price);
    }
}
public class Test1 {
    public static void main(String[]args){
        Book[] book =new Book[]{
                new Book("Java",79.8),
                new Book("C++",69.8),
                new Book("Python",75.8),
                new Book("C",63.8)
        };
        Arrays.sort(book);			//對象數組排序
        System.out.println(Arrays.toString(book));
    }
}
//結果：
//[書名：C,價格：63.8
//, 書名：C++,價格：69.8
//, 書名：Python,價格：75.8
//, 書名：Java,價格：79.8
//]

在上程序中，由於Book類在定義的時候實現了Comparable接口，所以在主類中調用Arrays.sort()方法時，會自動被Book類覆寫的compareTo()方法判斷對象的大小關係，按照價格由低到高進行排序。

數據結構——BinaryTree

先簡單介紹一下樹的操作原理：選擇第一個數據作爲根節點，而後比根節點小的放在根節點的左子樹(左節點)，比根節點大的數據放在右子樹(右節點)，取得數據時按照中序遍歷的方式取出(左——中——右)。

例：實現二叉樹

package Project.Study.BinaryTreeClass;

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;
    }
    @Override
    public String toString(){
        return "書名："+this.title+",價格："+this.price+"\n";
    }
    @Override
    public int compareTo(Book o){
        return Double.compare(this.price,o.price);
    }
}
@SuppressWarnings("rawtypes")
class BinaryTree{
    private class Node{
        private Comparable data;        //排序的依據就是Comparable
        private Node left;              //保存左節點
        private Node right;             //保存右節點
        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){					//左節點爲null
                    this.left=newNode;					//保存左節點
                }else{
                    this.left.addNode(newNode);			//繼續判斷節點保存位置
                }
            }else{
                if (this.right==null){					//右節點爲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){							//根節點爲null
            return null;								//沒有數據
        }
        this.foot=0;									//重置腳標
        this.retData=new Object[this.count];			//開闢保存數據數組
        this.root.toArrayNode();						//Node類處理
        return this.retData;							//返回保存的數據
    }
}
public class Test1 {
    public static void main(String[]args){
        BinaryTree bt=new BinaryTree();					//定義二叉樹
        bt.add(new Book("Java",79.8));					//保存數據
        bt.add(new Book("Python",75));
        bt.add(new Book("C++",76));
        bt.add(new Book("C",80));
        Object[] obj =bt.toArray();						//將數據轉換爲對象數組取出
        System.out.println(Arrays.toString(obj));		//利用Arrays類的方法輸出
    }
}
//結果：
//[書名：Python,價格：75.0
//, 書名：C++,價格：76.0
//, 書名：Java,價格：79.8
//, 書名：C,價格：80.0
//]

上程序實現了一個可以判斷節點大小關係的二叉樹數據結構。

挽救的比較器：Comparator

Comparator接口一般用於不能修改類定義時又需要進行對象數組排序的情況下。
該接口定義如下：

@FunctionalInterface
public interface Comparator<T>{
	public int compare(T o1,T o2);
	public boolean equals(Object obj);
}

由該定義我們可以發現，該接口定義了一個compare()方法，此方法的返回3種結果爲：1、-1、0.

例：利用Comparator接口實現對象數組排序

package Project.Study.ComparatorClass;

class Book{
    private String title;
    private double price;
    public Book(){}
    public Book(String title,double price){
        this.title=title;
        this.price=price;
    }
    @Override
    public String toString(){
        return "書名："+this.title+",價格："+this.price+"\n";
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public double getPrice() {
        return price;
    }
}
class BookComparator implements java.util.Comparator<Book>{	//假定Book類不能修改，所以爲Book類專門設計一個排序的規則類
    @Override
    public int compare(Book o1,Book o2){
        return Double.compare(o1.getPrice(),o2.getPrice());
    }
}
public class Test1 {
    public static void main(String[]args){
        Book[]books=new Book[]{
                new Book("Java",79.8),
                new Book("C++",69.8),
                new Book("Python",75.8),
                new Book("C",63.8)
        };
        java.util.Arrays.sort(books,new BookComparator());
        System.out.println(java.util.Arrays.toString(books));
    }
}
//結果：
//[書名：C,價格：63.8
//, 書名：C++,價格：69.8
//, 書名：Python,價格：75.8
//, 書名：Java,價格：79.8
//]