比较器

Arrays类

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;}@Overridepublic String toString(){return "书名："+this.title+",价格："+this.price+"\n";}@Overridepublic 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;}@Overridepublic String toString(){return "书名："+this.title+",价格："+this.price+"\n";}@Overridepublic int compareTo(Book o){return Double.compare(this.price,o.price);}
}
@SuppressWarnings("rawtypes")
class BinaryTree{private class Node{private Comparable data;        //排序的依据就是Comparableprivate 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){					//左节点为nullthis.left=newNode;					//保存左节点}else{this.left.addNode(newNode);			//继续判断节点保存位置}}else{if (this.right==null){					//右节点为nullthis.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){							//根节点为nullreturn 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;}@Overridepublic 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类专门设计一个排序的规则类@Overridepublic 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
//]