28、比较器

最新推荐文章于 2023-10-30 23:39:18 发布
最新推荐文章于 2023-10-30 23:39:18 发布
阅读量162 收藏
点赞数
分类专栏： # Java基础 文章标签： java 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/loiterer_y/article/details/107658052
版权

Arrays类

  1. Arrays类是java.util工具包中的一个类，主要用于对数组进行操作。
  2. 在Arrays类中存在有二分查找法：public static int binarySearch(数据类型[] a, 数据类型 key)
    二分查找举例：在1，2，3，4，5，6，7，8，9中找到2。
    先找到5，判断可得，2 比5小；在1-5间继续找，先找到3，2比3小；在1~3间继续找，找到了2。由该过程可得，二分查找前，数据必须进行排序。
    范例 ：二分查找
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) throws Exception {
        int data[] = new int[]{1, 9, 5, 7, 2, 3, 4, 6, 10, 8};
        // 未进行排序，二分查找可能失败，结果为负数
        System.out.println(Arrays.binarySearch(data, 9)); // -9
        java.util.Arrays.sort(data);
        // 数组排序后，二分查找成功
        System.out.println(Arrays.binarySearch(data, 9));
    }
}
  1. 在Arrays类中提供了数组比较equals()，该方法与Object类中的equals()没有任何关系：
    public static boolean equals(数据类型[] a, 数据类型[] a2)
    范例：实现数组比较
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) throws Exception {
        int dataA[] = new int[]{1, 2, 3};
        int dataB[] = new int[]{2, 1, 3};
        int dataC[] = new int[]{1, 2, 3};
        System.out.println(Arrays.equals(dataA, dataB)); // false
        System.out.println(Arrays.equals(dataA, dataC)); // true
    }
}

如果要使得数据判断为相同，数组中的元素顺序必须一致，因为该方法是按照顺序一个个比较元素的。
4. 在Arrays类中提供
·填充数组的方法：public static void fill(数据类型[] a, 数据类型 val)；
·将数组变为字符串输出：public static String toString(数据类型[] a)；

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) throws Exception {
        int data[] = new int[10];
        Arrays.fill(data, 3); // 填充数组
        System.out.println(Arrays.toString(data)); // 将数组变为字符串输出
    }
}

Comparable接口

  1. Arrays类中提供的数组排序方法：
    · 对象数组排序：public static void sort(Object[] a)；
    范例：使用sort()进行数组排序
import java.util.Arrays;

class 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;
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        Book books[] = new Book[]{
                new Book("Java开发", 66.6),
                new Book("JSP", 36.6),
                new Book("C++", 86.6),
                new Book("C", 16.6)
        };
        Arrays.sort(books); // 对象数组排序
        System.out.println(Arrays.toString(books));
    }
}

上述代码没有任何语法错误，但是执行后发生了异常

Exception in thread “main” java.lang.ClassCastException: com.java.demo.Book cannot be cast to java.lang.Comparable
at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
at java.util.Arrays.sort(Arrays.java:1246)
at com.java.demo.Demo.main(Demo.java:28)

造成这种异常的原因是两个没有关系的类对象发生了强制转换。
2. 每一个对象只保留有地址信息，地址中是有内容的，所以int型数组比较，只要判断大小；而对象数组，里面包含的只是编码（地址）比较是没意义的，像上述代码，按照价格排序才是有意义的，所以此处必须明确地设置出比较的规则。
比较的规则就是由Comparable接口定义的，此接口定义如下：
public interface Comparable<T> { public int compareTo(T o); }
实际上String类是Comparable接口的子类，之前使用的compareTo()方法就是比较的操作功能，如果现在要进行对象比较，建议compareTo()返回三类数据：1(大于)、0(等于)、-1(小于)。
范例：使用比较器

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()会自动调用此方法
        if (this.price > o.price) {
            return 1;
        } else if (this.price < o.price) {
            return -1;
        } else {
            return 0;
        }
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        Book books[] = new Book[]{
                new Book("Java开发", 66.6),
                new Book("JSP", 36.6),
                new Book("C++", 86.6),
                new Book("C", 16.6)
        };
        Arrays.sort(books); // 对象数组排序
        System.out.println(Arrays.toString(books));
    }
}

总结：

只要是一组对象要进行排序，对象所在的类一定要实现Comparable接口。

二叉树实现

  1. 树是一种比链表更复杂的概念，本质上也属于动态数组。但是与链表的不同在于，树可以针对数据进行排序。
    树的操作原理：选择第一个数据作为根节点，而后比根节点小的数据放在根节点的左子树（左节点），比根节点大的数据放在右子树（右节点），取得的数据按照中序遍历的方式取出结果（左-中-右顺序）。
    在任何数据结构中Node类的核心功能是保存真实数据以及配置节点关系。二叉树举例图：
    在这里插入图片描述
    范例：实现二叉树
    · 第一步：定义数据所在的类，该类要实现Comparable接口
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()会自动调用此方法
        if (this.price > o.price) {
            return 1;
        } else if (this.price < o.price) {
            return -1;
        } else {
            return 0;
        }
    }
}

· 定义二叉树，所有数据结构都需要Node类的支持

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()会自动调用此方法
        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; // 排序的依据就是Comparable
        private Node left; // 左节点
        private Node right; // 右节点

        @SuppressWarnings("unused")
        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; // 元素个数
    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);
        }
        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 Demo {
    public static void main(String[] args) throws Exception {
        BinaryTree bt = new BinaryTree();
        bt.add(new Book("Java开发", 66.6));
        bt.add(new Book("JSP", 36.6));
        bt.add(new Book("C++", 86.6));
        bt.add(new Book("C", 16.6));
        Object obj[] = bt.toArray();
        System.out.println(Arrays.toString(obj));
    }
}

Comparator接口

  1. comparator接口的特征是在类定义时就默认实现，现在一个类已经开发完善了。
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 String getTitle() {
        return title;
    }

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

    public double getPrice() {
        return price;
    }

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

假设上述在初期设计时，有对象数组，但是没有设置对象数组排序的方法。之后要实现对象数组的排序，这时在不能修改Book类定义的情况下是不能实现Comparable接口的。因此Java为解决该问题，提供了另外一个比较器：java.util.Comparator，原先在Comparator下定义了两个方法：

@FunctionalInterface
public interface Comparator<T> {
    public int compare(T o1, T o2);

    public boolean equals(Object obj);
}

上述代码中，实际真正要实现只有compare()方法，需要定义一个类实现Comparator接口，这个类将作为指定类的排序类。
范例：定义排序的工具类

class BookComparator implements Comparator<Book> {
    @Override
    public int compare(Book o1, Book o2) {
        if (o1.getPrice() > o2.getPrice()) {
            return 1;
        } else if (o1.getPrice() < o2.getPrice()) {
            return -1;
        } else {
            return 0;
        }
    }
}

Comparable接口的使用依靠Arrays类的sort()方法，而Comparator接口可以利用另一个被重载的sort()方法：public static <T> void sort(T[] a,Comparator<?super T>c)。
范例：进行排序

public class Demo {
    public static void main(String[] args) throws Exception {
        Book books[] = new Book[]{
                new Book("Java开发", 66.6),
                new Book("JSP", 36.6),
                new Book("C++", 86.6),
                new Book("C", 16.6)
        };
        Arrays.sort(books, new BookComparator());
        System.out.println(Arrays.toString(books));
    }
}

由该过程可得，使用Comparator比较麻烦，因为要定义一个专门的排序类，并且调用排序时也要明确地指明一个排序规则类。

题目：请解释Comparator和Comparable的区别？（请解释两种比较器的区别）
答案：
· 如果对象数组要进行排序那么必须设置排序规则，可以使用Comparator和Comparable接口实现；
· java.lang.Comparable是在一个类定义时实现的接口，这样该类数组就可以进行排序，在该接口下定义了一个public int compareTo()方法；
· java.util.Comparator是专门定义一个指定类的比较规则，用于进行挽救的比较操作，该接口下定义有两个方法public int compare()、public boolean equals()

不会画画的画师
关注
专栏目录
LM339比较器英文资料
04-05
LM339比较器是一款高性能、低功耗的四路独立电压比较器，其最大偏移电压仅为2mV，适用于各种精密应用场合。这款比较器设计独特，能够支持单电源供电模式，工作电压范围广泛，同时也能在双电源供电模式下运行。它的一...
【Java】比较器 Comparator & Comparable
liuwanqing233333的博客
01-22 2488
本文主要对比较器 Comparator 和 Comparable 进行了基本介绍，包括其使用示例
比较器： Comparable 与 Comparator 区别
weixin_61635597的博客
01-22 1642
自然排序的当我们想对自定的类，进行排序时可以重写 Comparable 接口中的抽象方法，默认一些已经实现 Comparable 接口的并重写了 compareTo()抽象方法，String，Doubel，Arrays 默认时升序的。如果当前对象this > 形参对象Obj，则返回正整数。如果当前对象 this < 形参对象 Obj，则返回负整数，如果当前对象 this == 形参对象 Obj，则返回 0降序则是相反的：如果当前对象this < 形参对象Obj，则返回正整数。
深入理解Java比较器（Comparable和Comparator）
qq_45830276的博客
09-06 4448
若一个类实现了Comparable接口，就意味着该类支持排序。实现了 Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。 对于我们想从其他成员变量来排序，那么此时我们就需要比较器来实现。
Java中的排序接口Comparable和比较器Comparator详解
热门推荐
向上的"狼"的博客
08-07 1万+
Java中的排序接口Comparable和比较器Comparator详解
Comparable比较器和Comparator比较器
qq_60030399的博客
01-16 831
Comparable比较器和Comparator比较器
超小体积运放和比较器芯片.pdf
07-26
5. 超小体积运放和比较器芯片：STMicroelectronics公司发布的LM2904WHYST双运放和LM2903WHYST双比较器采用了4.9mm×3.0mm的ISO8封装，工作温度范围极宽(-40～+150℃)，确保汽车系统在恶劣工况下的稳健性和适应性。...
基于微控制器提供电源保护的集成模拟比较器
08-13
这些微控制器集成了模拟比较器，使得电源保护功能更加高效且节省板级空间。集成模拟比较器的功能使得设计师能够在电机控制和数字电源系统中减少对额外外部模拟组件的需求。 Piccolo微控制器采用TI的TMS320C28x内核...
电源技术中的基于微控制器提供电源保护的集成模拟比较器
10-21
Piccolo微控制器系列集成了模拟比较器功能，使得在微控制器自身出现故障时，系统仍然能有效防止过压、欠压、过流和欠流等状况，确保系统的稳定性和安全性。 Piccolo微控制器基于TI的TMS320C28x内核，提供高性能计算...
List对象集合的排序：比较器Comparator（简单例子）
01-13
List对象集合的排序：比较器Comparator
比较器Comparator简单用法
09-29
简单的用commons的jar包，运用其中Comparator的方法，希望对你有所帮助。
java比较器:Comparable和Comparator
m0_68721674的博客
05-28 585
1.Comparable是java.lang包下的，Comparator是java.util包的；2.Comparable接口使用时需要重写compareTo(T o)方法，实现Comparator接口必须重写compare(T o1,T o2)方法；3.Comparable接口使用时需要修改实体类的代码，而Comparator接口使用时则不需要；4.Comparator与Comparable同时存在的情况下，比较器Comparator优先级高。
Comparator比较器
Infinite Progress
04-11 1395
Comparator使用方法
Comparator--比较器
小旭IT-分享技术
08-14 2271
Comparator--比较器前言一、Comparator概念二、使用方法总结 前言 今天在看系统自代堆的定义的时候发现了一个好东西，值得分享，那就是比较器 一、Comparator概念 定义： Comparator是外部比较器，用于比较来对象与对象之间的，两个对象进行比较，多用于集合排序，而Comparable可以认为是一个内比较器，根据对象某一属性进行排序的。 我的理解 需要将一个混乱的数组或者集合通过一定的规律输出时（升序或者降序）可以使用这个外部的比较器，他可以将一个定义的几..
【Java基础教程】（三十九）常用类库篇 · 第九讲：比较器——Comparable和 Comparator的讲解~
Technology changes the world of life
07-21 654
Comparable 接口是在要比较的对象类中实现的，用于定义对象之间的自然顺序。它有一个compareTo()方法，用于比较当前对象与参数对象的顺序。实现了Comparable接口的类可以直接使用排序算法（如Arrays.sort()或Collections.sort()）进行排序。 Comparator 接口是独立于被比较的对象类的。它用于创建一个单独的比较器对象，并实现了compare()方法来定义不同对象之间的比较逻辑。通过提供自定义的Comparator对象，可以对任意对象进行排序...
详解Comparable接口与Comparator接口的使用及区别
最新发布
lengyu15的博客
10-30 640
详细分析和讲解了Comparable接口和Comparator接口的具体使用和区别
sar adc动态比较器设计
07-27
动态比较器是SAR ADC（逐次逼近型模数转换器）中的一个重要组成部分。它用于将输入信号与参考电压进行比较，并产生一个数字输出。动态比较器的设计可以采用LATCH比较器结构。\[1\] LATCH比较器由两个背靠背的反相器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值