Java学习总结：37(比较器)

比较器

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;
    }
    @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
//]

转载：https://blog.csdn.net/weixin_45784666/article/details/105279267