比较器： Comparable 与 Comparator 区别

news2024/9/25 21:26:36

比较器： Comparable 与 Comparator 区别

在这里插入图片描述

每博一文案

师父说: 人不能精得过火，太精明的人往往让人生厌，人也别傻的可怜，一腔热血付出却白忙一场。
太精明的人，凡事都想要争个明明白白，每一分钱都要和人计较。把便宜占尽，把好事包揽，
时间长了，即使再好的朋友也会离去，过于精明就成了算计，成了小肚鸡肠，没有人原意和这样的人相处。
太老实的人，更容易被别人欺负，对人付出要看值不值得，你的付出是否会得到他的回应。
帮助别人要看自己能力，做不到的事情就不要勉强自己。别为了面子委屈自己，
拒绝总比敷衍和拖延来的更好，别惯坏了得寸进尺的人，把你的付出当成理所当然，
别纵容了不知感恩的心，把你的好意当成傻子嬉戏。
对你好的人，要加倍珍惜，把你冷的人，要趁早远离，别精地过火，也别傻得可怜，
做人做事，无愧于心就好。 
                                  ——————   一禅心灵庙语

文章目录

    • 比较器： Comparable 与 Comparator 区别
    • 每博一文案
    • 1. 自然排序：java.lang.Comparable
    • 2. 定制排序：java.util.Comparator
    • 3. Comparable 与 Comparator 的区别
    • 4. 总结：
    • 5. 最后：

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。

  • Java实现对象排序的方式有两种：

  • 自然排序： java.lang.Comparable

  • 定制排序： java.util.Comparator

1. 自然排序：java.lang.Comparable

  • Comparable 的典型实现 (默认都是从小到大排序)

在这里插入图片描述

  • String : 按照字符串中字符的 Unicode 值进行比较。
  • Character : 按照字符的 Unicode 值进行比较。
  • 数值类型对应的包装类以及 Biglnteger，BigDecimal ，按照它们对应的数值大小进行比较。默认是升序(从小到大) 排序的。
  • Boolean: true 对应的包装类实例大于 false 对应的包装类实例。
  • Date，Time 等： 后面的日期时间比前面的日期时间大。
  • Comparable j接口强行对实现它的每个类的对象进行整体排序，这种排序被称为 类排序 。
  • 实现 Comparable 的类必须实现 其中的 compareTo(object obj) 方法，两个对象即通过 comparTo(Object obj) 方法的返回值来比较大小。
  • 在这里插入图片描述

在这里插入图片描述

  • 默认是升序：比较的规则是：
    • 如果当前对象 this > 形参对象 obj ，则返回正整数。
    • 如果当前对象 this < 形参对象obj ，则返回负整数。
    • 如果当前对象 this == 形参对象 obj，则返回 0
  • 实现 Comparable 接口的对象列表(和数组)，可以通过 Collections.sort() 或 Arrays.sort() 进行排序，实现此接口的对象可以用作，有序映射中的键或有序集合中的元素，无需指定 比较器。
  • 比如： 对于 类 C 的每一个 e1 和 e2 来说，当且仅当 e1.comparTo(e2) == 0 与 e1.equals(e2) ，具有相同的 boolean 值时，类 C的自然排序才叫做 equals 一致，建议(虽然不是必需的) 最好使 自然排序 与 equals 一致。
  • 说明:
    • Java 中的对象，正常情况下，只能进行比较，== 或 != ，不能使用 > 或 < 的，但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。如何实现 ？？？ 使用 实现 两个接口中的任何一个 Comparable 或 Comparato 。

举例: 使用 Arrays 中的 sort 排序

import java.util.Arrays;

public class Comparable {
    public static void main(String[] args) {
        String[] arr = {"AA","CC","BB","FF","DD","EE"};
        // 排序前:
        System.out.println(Arrays.toString(arr));
        // 排序后:
        Arrays.sort(arr);  // 排序默认是(升序)
        System.out.println(Arrays.toString(arr));

    }
}

在这里插入图片描述

举例： 自定义一个商品类，属性：String name(商品名)，double price(商品的价格) ，通过商品的价格进行升序排序。

  • 像String ，包装类实现了 Comparable 接口，并重写 compareTo(） 方法，给出了比较两个对象大小。
    • 重写 compareTo() 的规则：
      • 如果当前对象this > 形参对象Obj，则返回正整数。
      • 如果当前对象 this < 形参对象 Obj，则返回负整数，
      • 如果当前对象 this == 形参对象 Obj，则返回 0
  • 在定义类来说，如果需要排序，我们可以让自定义类实现 Comparable 接口，重写 compartTo() 在compareTo(obj) 方法中指明
    如何排序的。

在这里插入图片描述

自定义类 implements Comparable 实现该接口，并重写了其中的 compareTo()抽象方法 后就可以比较了。

import java.util.Arrays;


class Commodity implements Comparable {
    String name;
    double price;

    public Commodity() {
        // 无参构造器
    }

    public Commodity(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

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

    @Override
    public int compareTo(Object o) {
        /**
         * 比较规则:
         * * 如果当前对象this > 形参对象Obj，则返回正整数。
         * * 如果当前对象 this < 形参对象 Obj，则返回负整数，
         * * 如果当前对象 this == 形参对象 Obj，则返回。
         */
        // 1. 首先判断该类，是否是 Commodity 的实例，不是就不用比较了，类都不一样
        if (o instanceof Commodity) {
            // 2.强制转换为对应的 Commodity 的实例对象，获取到其中的比较值
            Commodity commodity = (Commodity) o;

            if(this.price > commodity.price) {
                return 1;
            } else if(this.price < commodity.price) {
                return -1;
            } else {
                return 0;   // 两个对象比较的值相等。
            }

        }
        // 抛出运行异常
        throw new RuntimeException("传入的数据类型不一致");
    }

    @Override
    public String toString() {
        return "Commodity{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


public class ComparableTest {
    public static void main(String[] args) {
        Commodity[] commodities = new Commodity[5];
        commodities[0] = new Commodity("lenovoMouse", 34);
        commodities[1] = new Commodity("dellMouse", 43);
        commodities[2] = new Commodity("xiaoMouse", 12);
        commodities[3] = new Commodity("huaweiMouse", 65);
        commodities[4] = new Commodity("roogyao", 35);

        Arrays.sort(commodities);

        System.out.println(Arrays.toString(commodities));
    }
}

在这里插入图片描述

修改重写： compareTo() 的比较规则，根据商品的价格进行降序排序

规则:

  • 如果当前对象this < 形参对象Obj，则返回正整数。
  • 如果当前对象 this > 形参对象 Obj，则返回负整数，
  • 如果当前对象 this == 形参对象 Obj，则返回 0
import java.util.Arrays;


class Commodity implements Comparable {
    String name;
    double price;

    public Commodity() {
        // 无参构造器
    }

    public Commodity(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

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

    @Override
    public int compareTo(Object o) {
        /**
         * 比较规则:
         * * 如果当前对象this > 形参对象Obj，则返回正整数。
         * * 如果当前对象 this < 形参对象 Obj，则返回负整数，
         * * 如果当前对象 this == 形参对象 Obj，则返回。
         */
        // 1. 首先判断该类，是否是 Commodity 的实例，不是就不用比较了，类都不一样
        if (o instanceof Commodity) {
            // 2.强制转换为对应的 Commodity 的实例对象，获取到其中的比较值
            Commodity commodity = (Commodity) o;

            if(this.price > commodity.price) {
                return -1;
            } else if(this.price < commodity.price) {
                return 1;
            } else {
                return 0;   // 两个对象比较的值相等。
            }

        }
         // 抛出运行异常
        throw new RuntimeException("传入的数据类型不一致");
    }

    @Override
    public String toString() {
        return "Commodity{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


public class ComparableTest {
    public static void main(String[] args) {
        Commodity[] commodities = new Commodity[5];
        commodities[0] = new Commodity("lenovoMouse", 34);
        commodities[1] = new Commodity("dellMouse", 43);
        commodities[2] = new Commodity("xiaoMouse", 12);
        commodities[3] = new Commodity("huaweiMouse", 65);
        commodities[4] = new Commodity("roogyao", 35);

        Arrays.sort(commodities);

        System.out.println(Arrays.toString(commodities));
    }
}

在这里插入图片描述

升级需求：

先对商品的价格进行升序排序，如果商品的价格是一样的，就对其中的商品名进行二次降序排序。

import java.util.Arrays;


class Commodity implements Comparable {
    String name;
    double price;

    public Commodity() {
        // 无参构造器
    }

    public Commodity(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

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


    @Override
    public String toString() {
        return "Commodity{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        /**
         * 比较规则:
         * * 如果当前对象this > 形参对象Obj，则返回正整数。
         * * 如果当前对象 this < 形参对象 Obj，则返回负整数，
         * * 如果当前对象 this == 形参对象 Obj，则返回。
         */
        // 1. 首先判断该类，是否是 Commodity 的实例，不是就不用比较了，类都不一样
        if (o instanceof Commodity) {
            // 2.强制转换为对应的 Commodity 的实例对象，获取到其中的比较值
            Commodity commodity = (Commodity) o;
            if (this.price > commodity.price) {
                return -1;
            } else if (this.price < commodity.price) {
                return 1;
            } else {
                // 对于价格相同的商品，对商品名进行“降序” 二次排序
                // 这里我们直接调用 String 类型中已经重写好的 compareTo()方法就进行排序
                return this.name.compareTo(commodity.name);  // compareTo()默认就是 “升序”
            }

        }
        throw new RuntimeException("传入的数据类型不一致");
    }

}


public class ComparableTest {
    public static void main(String[] args) {
        Commodity[] commodities = new Commodity[5];
        commodities[0] = new Commodity("lenovoMouse", 34);
        commodities[1] = new Commodity("dellMouse", 34);
        commodities[2] = new Commodity("xiaoMouse", 12);
        commodities[3] = new Commodity("huaweiMouse", 65);
        commodities[4] = new Commodity("roogyao", 65);

        Arrays.sort(commodities);

        System.out.println(Arrays.toString(commodities));
    }
}

在这里插入图片描述

解析：

return -this.name.compareTo(commodity.name);

为什么填一个 "-" 符号

这里我们直接调用 String 类型中已经重写好的 compareTo()方法就进行排序

这里我们 附加一个 "-1"负数的意思是：compareTo()默认就是 “升序”

升序: this > 参数对象，返回正整数，this < 参数对象，返回负整数

降序: this > 参数对象，返回负整数, this < 参数对象，返回正整数

这两者的结果刚好相反：所以：我们将升序的返回结果 填一个 “-” 负号就变成了：降序

同理：将降序的返回结果，填一个 - 负号，就变成了：升序

2. 定制排序：java.util.Comparator

在这里插入图片描述

  • 当元素的类型没有实现 java.lang.Comparable 接口而又不方便修改代码，或者实现了java.lang.Comparable 接口的排序不合适当前的操作，那么可以考虑使用 Comparator 的对象来排序，强行对多个地下进行整体排序的比较。
  • 重写compare(Object o1, Object o2) 方法，比较规则和: Comparable() 是一样的。

在这里插入图片描述

在这里插入图片描述

  • 升序的：比较规则:
    • 如果当前对象 this > 形参对象 obj ，则返回正整数。
    • 如果当前对象 this < 形参对象obj ，则返回负整数。
    • 如果当前对象 this == 形参对象 obj，则返回 0
  • 可以将 Comparato 传递给 sort() 方法，如 (Collections.sort) 或 Arrays.sort) ，从而允许在排序顺序上实现精度控制。
  • 还可以使用 Comparator 来控制某些数据结构 (如有序 set 或有序映射)的顺序，或者为那些没有自然顺序的对象的 collection 提供排序。
  • 一般对于 Comparator的使用都是一次性的，所以一般都是使用匿名的方式

举例: 对 String 数组中的内容进行 降序排序

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorTest {
    public static void main(String[] args) {
        String[] arr = {"AA", "CC", "DD", "GG", "EE", "FF", "DD", "ZZ"};

        // 排序前
        System.out.println(Arrays.toString(arr));

        // 通过匿名实现 Comparator 接口,并重写其中的 compare()抽象方法
        Arrays.sort(arr, new Comparator() {

            // 重写 compare()抽象方法，降序
            @Override
            public int compare(Object o1, Object o2) {
                // 1. 首先判断：是否是比较的对象的类型
                if (o1 instanceof String && o2 instanceof String) {
                    // 2. 强制转换为对于的实例对象，获取到比较的值
                    String s1 = (String) o1;
                    String s2 = (String) o2;

                    // 3. 这里我们调用 String 已经重写好的 compareTo()方法，默认是升序
                    // 这里我们附加上一个 '-' 负号变成，降序
                    return -s1.compareTo(s2);
                }
                // 异常可以代替 return 返回值
                throw new RuntimeException("比较类型不一致");
            }
        });

        // 排序后的结果:
        System.out.println(Arrays.toString(arr));
    }
}

在这里插入图片描述

3. Comparable 与 Comparator 的区别

  • Comparable 和 Comparator 都是接口。都有定义好的比较的抽象方法 , Comparable 的是 comparTo() ，Comparator 的是compare()
  • Comparable 的是 comparTo() 是一个参数，比较的是 this 当前对象 与 参数对象的比较
  • Comparator 的是compare(Object o1 , Object o2) 的是两个参数,比较的是 参数 o1 对象 与 参数 o2对象的比较
  • Comparable 中的 comparTo()的抽象方法已经被大部分 类已经重写了，我们是不可以修改的，比如 String ,Doubel 类就已经重写了 comparTo()抽象方法，并且 String 是被 final 修饰的是无法继承，再重写 comparTo()抽象方法的，就导致 String 中的 comparTo()一直只能时默认的升序了 ，当我们要对 String 类型的数据进行降序 排序时，就无法实现了。这时候，我们就可以通过 重写 Comparator 的是compare()抽象方法，定制自己所需要的排序规则 时降序，还是升序了。
  • 一般对于 Comparator的使用都是一次性的，所以一般都是使用匿名的方式
Arrays.sort(arr, new Comparator() {

            // 重写 compare()抽象方法，降序
            @Override
            public int compare(Object o1, Object o2) {
                // 1. 首先判断：是否是比较的对象的类型
                if (o1 instanceof String && o2 instanceof String) {
                    // 2. 强制转换为对于的实例对象，获取到比较的值
                    String s1 = (String) o1;
                    String s2 = (String) o2;

                    // 3. 这里我们调用 String 已经重写好的 compareTo()方法，默认是升序
                    // 这里我们附加上一个 '-' 负号变成，降序
                    return -s1.compareTo(s2);
                }
                // 异常可以代替 return 返回值
                throw new RuntimeException("比较类型不一致");
            }
        });

4. 总结：

  • 自然排序的当我们想对自定的类，进行排序时可以重写 Comparable 接口中的 int compareTo(T o) 抽象方法，默认一些已经实现 Comparable 接口的并重写了 compareTo()抽象方法，String，Doubel，Arrays 默认时升序的。
  • 升序的规则:
    • 如果当前对象this > 形参对象Obj，则返回正整数。
    • 如果当前对象 this < 形参对象 Obj，则返回负整数，
    • 如果当前对象 this == 形参对象 Obj，则返回 0
  • 降序则是相反的：
    • 如果当前对象this < 形参对象Obj，则返回正整数。
    • 如果当前对象 this > 形参对象 Obj，则返回负整数，
    • 如果当前对象 this == 形参对象 Obj，则返回 0
  • 升序和降序的刚好是相反的，将升序的返回结果 填一个 “-” 负号就变成了：降序同理：将降序的返回结果，填一个 - 负号，就变成了：升序。
  • 当 Comparable 接口中的抽象方法的排序，无法满足我们的时候，我们可以实现 Comparator 接口中的 int compare(T o1,T o2) 定制自己需要的排序规则
  • 一般对于 Comparator的使用都是一次性的，所以一般都是使用匿名的方式

5. 最后：

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，江湖再见，后会有期 ！！！

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/175743.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

macOS Ventura 13.1 系统问题：掉电快 充电慢

macOS Ventura 13.1 系统问题：掉电快 充电慢

今年一月份升级了 MBA 的系统&#xff0c;之后的笔记本&#xff1a; 使用过程&#xff1a;电量不禁用&#xff0c;掉电很快。 充电过程&#xff1a;很慢。而且存在一定几率&#xff1a;电量充到某个值&#xff08;如30%&#xff09;之后不管再充多久还是这个电量值。 系统信息…
阅读更多...
HDFS高可用单NameNode从standby恢复为active（二）

HDFS高可用单NameNode从standby恢复为active（二）

1、背景 有一个hdfs高可用集群&#xff0c;因为某些操作&#xff0c;导致其中一个namenode的信息全部丢失了。最后只剩下一个完整的namenode信息和datanode信息。于是在在启动hdfs后发现独有的namenode始终处于standby状态。即使通过hdfs haadmin -transitionToActive命令也不能…
阅读更多...
java面向接口编程2023027

java面向接口编程2023027

那就再进一步&#xff1a;面向接口编程 面向接口编程前面已经提到&#xff0c;接口体现的是一种规范和实现分离的设计哲学&#xff0c;充分利用接口可以极好地降低程序各模块之间的耦合&#xff0c;从而提高系统的可扩展性和可维护性。 基于这种原则&#xff0c;很多软件架构设…
阅读更多...
Leetcode——第 329 场周赛

Leetcode——第 329 场周赛

题目链接&#xff1a; 交替数字和 根据第 K 场考试的分数排序 执行逐位运算使字符串相等 拆分数组的最小代价 题目描述 交替数字和 给你一个正整数 n 。n中的每一位数字都会按下述规则分配一个符号&#xff1a; 最高有效位 上的数字分配到 正 号。 剩余每位上数字的符号都与…
阅读更多...
学习记录666@项目管理之项目质量管理

学习记录666@项目管理之项目质量管理

什么项目质量管理 所谓项目质量&#xff0c;是项目满足需求的程度&#xff1b;所谓质量管理&#xff0c;就是为了使项目满足需求的程度足够高或者是合适程度下而进行的一系列管理活动。 包括规划质量管理、实施质量保证、质量控制三个方面。 规划质量管理 规划质量管理主要…
阅读更多...
JUC面试（七）——CountDownLatchCyclicBarrierSemaphore

JUC面试（七）——CountDownLatchCyclicBarrierSemaphore

CountDownLatch 概念 让一些线程阻塞直到另一些线程完成一系列操作才被唤醒 CountDownLatch主要有两个方法&#xff0c;当一个或多个线程调用await方法时&#xff0c;调用线程就会被阻塞。其它线程调用CountDown方法会将计数器减1&#xff08;调用CountDown方法的线程不会被…
阅读更多...
nacos源码分析==客户端从服务端读取配置文件-服务端服务注册

nacos源码分析==客户端从服务端读取配置文件-服务端服务注册

客户端从服务端读取配置文件 客户端启动的时候会扫描到boostrap.yml中的信息&#xff0c;扫描到标签ConditionalOnProperty会将NacosConfigBootstrapConfiguration 中的bean注入。其中NacosConfigProperties就是读取的boostrap.yml中spring.cloud.nacos.config下的配置项。Nac…
阅读更多...
“深度学习”学习日记。与学习有关的技巧--权重的初始值

“深度学习”学习日记。与学习有关的技巧--权重的初始值

2023.1.22 在深度学习的学习中&#xff0c;权重的初始值特别重要。这关系到神经网络的学习能否成功&#xff1b; 在以前误差反向传播法和神经网络学习的算法实现这两篇文章中&#xff0c;对权重的初始值的确定是这样的&#xff1a; class TwoLayerNet:def __init__(self, inp…
阅读更多...
在2022年的最后一天我学会了哈希表

在2022年的最后一天我学会了哈希表

文章目录前言STL相关容器unordered_setunordered_map哈希表哈希冲突闭散列开散列STL相关容器的模拟实现用一个哈希表改造两个容器哈希表的迭代器总结前言 首先先提前祝贺大家新年快乐&#xff01;本文是农历2022年的最后一篇博客。而今天我们介绍的也是STL里面重要的一个数据结…
阅读更多...
2023年, 前端路上的开源总结(最新更新...)

2023年, 前端路上的开源总结(最新更新...)

19年至今, 笔者利用空余时间陆陆续续做了一些开源项目, 大部分开源项目都是以实际价值为开源基础, 所以我觉得有必要做一个总结和复盘,在复盘的过程中希望也能对大家有所帮助.今后笔者的开源项目都会放在这篇文章中,如果想学习的可以收藏交流.1. 基于react实现的滑动验证码组件…
阅读更多...
[LeetCode周赛复盘] 第 96 场双周赛20230121

[LeetCode周赛复盘] 第 96 场双周赛20230121

[LeetCode周赛复盘] 第 96 场双周赛20230121 一、本周周赛总结二、 [Easy] 6300. 最小公共值1. 题目描述2. 思路分析3. 代码实现三、[Medium] 6275. 使数组中所有元素相等的最小操作数 II1. 题目描述2. 思路分析3. 代码实现四、[Medium] 6302. 最大子序列的分数1. 题目描述2. 思…
阅读更多...
【JavaScript】33_对象的序列化----JSON

【JavaScript】33_对象的序列化----JSON

3、对象的序列化 对象的序列化 JS中的对象使用时都是存在于计算机的内存中的 序列化指将对象转换为一个可以存储的格式 在JS中对象的序列化通常是一个对象转换为字符串&#xff08;JSON字符串&#xff09;序列化的用途&#xff08;对象转换为字符串有什么用&#xff09;&…
阅读更多...
Linux嵌入式开发——文件系统结构

Linux嵌入式开发——文件系统结构

文章目录Linux嵌入式开发——文件系统结构一、根目录“/”二、Ubuntu文件系统结构三、绝对路径和相对路径Linux嵌入式开发——文件系统结构 一、根目录“/” ​ Linux下“/”就是根目录&#xff01;所有的目录都是由根目录衍生出来的。 二、Ubuntu文件系统结构 /bin 存放二进…
阅读更多...
第十届蓝桥杯省赛 C++ A/B组 - 完全二叉树的权值

第十届蓝桥杯省赛 C++ A/B组 - 完全二叉树的权值

✍个人博客&#xff1a;https://blog.csdn.net/Newin2020?spm1011.2415.3001.5343 &#x1f4da;专栏地址&#xff1a;蓝桥杯题解集合 &#x1f4dd;原题地址&#xff1a;蜂巢 &#x1f4e3;专栏定位&#xff1a;为想参加蓝桥杯的小伙伴整理常考算法题解&#xff0c;祝大家都能…
阅读更多...
Linux C编程一站式学习笔记4

Linux C编程一站式学习笔记4

Linux C编程一站式学习笔记 chap4 分支语句 文章目录Linux C编程一站式学习笔记 chap4 分支语句一.if语句语句块习题二.if/else语句引例if/else语句 语法规则if else 的配对原则习题1、写两个表达式&#xff0c;分别取整型变量x的个位和十位2、写一个函数&#xff0c;参数是整型…
阅读更多...
常见流对象的使用

常见流对象的使用

文章目录一、缓冲流字节缓冲流字符缓冲流二、转换流字符输入转换流字符输出转换流三、对象序列化对象序列化对象反序列化四、打印流PrintStreamPrintWriter一、缓冲流 缓冲流&#xff1a;也叫高效流或者高级流&#xff0c;我们之前学的字节流称为原始流&#xff0c;缓冲流自带…
阅读更多...
【JavaSE】浅析String与StringTable

【JavaSE】浅析String与StringTable

文章目录1. 前言2. String的两种创建方式2.1 通过new关键字创建一个字符串对象2.2 采用双引号的方式来创建字符串对象2.3 两种方式的区别3. StringTable的位置4. String的intern()方法5. 判断两个字符串是否相等5.1 equals5.2 1. 前言 String类是开发中经常使用的一个类。 对…
阅读更多...
第七层：多态

第七层：多态

文章目录前情回顾多态多态的基本概念动态多态的满足条件动态多态的使用虚函数多态的优点纯虚函数和抽象类抽象类特点虚析构和纯虚析构虚析构和纯虚析构的共性虚析构和纯虚析构的区别面向对象结束&#xff0c;接下来是什么?本章知识点&#xff08;图片形式&#xff09;&#x1…
阅读更多...
数据结构进阶 哈希桶

数据结构进阶 哈希桶

作者&#xff1a;小萌新 专栏&#xff1a;数据结构进阶 作者简介&#xff1a;大二学生 希望能和大家一起进步&#xff01; 本篇博客简介&#xff1a;模拟实现高阶数据结构 哈希桶 哈希桶哈希冲突的另一种解决方法开散列 -- 链地址法举例哈希表的开散列实现 --哈希桶哈希表的结构…
阅读更多...
自动化测试Selenium【基础篇二】

自动化测试Selenium【基础篇二】

自动化测试Selenium【基础篇二】&#x1f34e;一.Selenium基础使用&#x1f352;1.1 信息打印&#x1f349; 1.1.1打印标题&#x1f349; 1.1.1打印当前网页标题&#x1f352;1.2 窗口&#x1f349;1.2.1 获取句柄&#x1f349;1.2.2 窗口切换&#x1f349;1.2.3 窗口大小设置&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023