标签：roo   obj   string   str   dem   new   节点   操作   工具   

比较器

Arrays 类

主要功能：

• 完成所有与数组有关的操作的工具类

二分查找：

• 在一个有序的数字序列中进行二分查找

public static int binarySearch(数据类型 [] a , 数据类型 key)

案例实现

public class TestDemo {
    public static void main(String [] args) throws ParseException {
        int date [] = new int [] {1,4,2,5,7,4,3,8} ;
        java.util.Arrays.parallelSort(date); // 排序
        System.out.println(Arrays.binarySearch(date, 3)); // 二分查找
        
    }
}

数组比较：

public static boolean equals(数据类型 [] a , 数据类型 [] b)

和Object.equals()没有任何关系，本次的arrays中的equals比较的是数组不是对象。

public class TestDemo {
    public static void main(String [] args) throws ParseException {
        int dateA [] = new int [] {1,4,2,5,7,4,3,8} ;
        int dateB [] = new int [] {1,4,2,5,7,4,3,8} ;
        System.out.println(Arrays.equals(dateA, dateB));
    }
}

比较器：Comparable *

对象数组排序

public static void sort(Object [] a);

Arrays类可以直接利用 sort() 方法实现对象数组的排序

• 测试代码 *

class Book implements Comparable { //使用比较器
    private String title ; 
    private double price ; 
    public Book (String title , double price) {
        this.title = title ;
        this.price = price ; 
        
    }
    public String toString() {
        return this.title + "   " + this.price;
    }
    @Override
    public int compareTo(Book o) { 
        // compareTo 方法由 Arrays.sort()方法自动调用
        if (this.price > o.price) {
            return 1 ;
        } else if (this.price 

要对某个对象进行数组排序，对象所在的类一定要实现 Comparable 接口，覆写compareTo()方法。

二叉树结构：BinaryTree

• 数，是一种比链表更为复杂的概念，本质也属于动态对象数组，但是与链表相比，数更有利于数据进行排序。

数的操作原理

• 选择一个数据作为根节点，而后比根节点小的数据放在根节点左节点，比左节点小的放在根节点的右节点。按照 中序 进行遍历。

class Book implements Comparable { //使用比较器
    private String title ; 
    private double price ; 
    public Book (String title , double price) {
        this.title = title ;
        this.price = price ; 
        
    }
    public String toString() {
        return this.title + "   " + this.price;
    }
    @Override
    public int compareTo(Book o) { 
        // compareTo 方法由 Arrays.sort()方法自动调用
        if (this.price > o.price) {
            return 1 ;
        } else if (this.price 

Comparator接口(下下策)

• 该接口是一个函数式接口：即只有继承方法

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

我们可以借助该接口，将没有实现Comparable接口的类，进行改变；

实现该接口，创建一个“工具类”，实现Book类对象的排序需求

class Book { 
    private String title ; 
    private double price ; 
    public Book (String title , double price) {
        this.title = title ;
        this.price = price ; 
    }
    public String getTitle() {
        return title;
    }
    public double getPrice() {
        return price;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String toString() {
        return this.title + "   " + this.price;
    }
}

class BookComparator implements Comparator{ // 比较器工具
    @Override
    public int compare(Book o1, Book o2) {
        if (o1.getPrice() > o2.getPrice()) {
            return 1;
        } else if (o1.getPrice() > o1.getPrice()){
            return -1;
        }else {
            return 0 ;
        }
    }
}

public class TestDemo {
    public static void main(String [] args) {
        Book books [] = new Book [] {
                new Book("java",23),
                new Book("python",20),
                new Book("php",11),
                new Book("C/C++",44)
        } ;
        Arrays.parallelSort(books,new BookComparator());
        
        System.out.println(Arrays.toString(books));
    }
}

• 区别：

  comparable是在一个类定义阶段实现的接口类，而comparator则需要专门定义一直指定的类。

总结

• 涉及到对象数组的排序，就使用Comparable接口
• 根据实际情况掌握 二叉树代码

Java 比较器

标签：roo   obj   string   str   dem   new   节点   操作   工具   

原文地址：https://www.cnblogs.com/wangyuyang1016/p/11109725.html