标签：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<Book> { //使用比较器
    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 < o.price){
            return -1 ;
        } else {
            return 0 ;
        }
    }
}

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

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

二叉树结构：BinaryTree

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

数的操作原理

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

class Book implements Comparable<Book> { //使用比较器
    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 < o.price){
            return -1 ;
        } else {
            return 0 ;
        }
    }
}

class BinaryTree {
    private class Node{
        private Comparable data ;
        private Node left ;
        private Node right ; 
        public Node (Comparable data) {
            this.data = data ;
        }
        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 = 0 ;
    private Object [] retData;
    private int foot;
    public void add(Object obj) {
        Comparable com = (Comparable) obj ;// 必须转为 Comparable
        Node newNode = new Node(com); //创建新的Node节点
        if (this.root == null) {
            this.root = newNode ;
        } else {
            this.root.addNode(newNode);
        }
        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 TestDemo {
    public static void main(String [] args) {
        BinaryTree bt = new BinaryTree();
        bt.add(new Book("java",23));
        bt.add(new Book("python",20));
        bt.add(new Book("php",11));
        bt.add(new Book("C/C++",44));
        Object obj [] = bt.toArray();
        
        System.out.println(Arrays.toString(obj));
    }
}

Comparator接口(下下策)

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

@FunctionalInterface
public interface Comparator<T> {
    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<Book>{ // 比较器工具
    @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