Java的contains()方法实现原理——equals(),hashcode() 实例分析

最新推荐文章于 2024-08-11 23:47:16 发布
最新推荐文章于 2024-08-11 23:47:16 发布
阅读量7.4k 收藏 5
点赞数 3
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，转载请注明出处。
本文链接：https://blog.csdn.net/weixin_43850377/article/details/88754080
版权

Java编程离不开容器，使用容器又会常常用到contains()方法，这篇文章通过极其详细的测试，探究了 java 中 contains() 方法实现的底层原理。

索引

第一波测试
  • String 和自定义 object 类之间储存方式的区别
  • String 和 object在使用 contains 时的差别
  • List Set Map 的不同表现
//注释为false的是错误，没写的是true

import java.util.*;

import javax.print.attribute.HashAttributeSet;

public class contains{
    public static void main(String[] args){

        String str1 = "aaa";
        String str11 = "aaa";
        String str2 = "bbb";

        //string 存储方式，重复字符串不会另行开辟空间
        System.out.println("String storage test:");
        System.out.println(str1 == "aaa");
        System.out.println(str1 == str11);
        System.out.println(str1.equals(str2));// false
        System.out.println(str1.equals("aaa"));

        Person p1 = new Person("A", 1);
        Person p11 = new Person("A", 1);
        Person p2 = new Person("B", 2);

        //new几个就有几个空间
        System.out.println("\nObject storage test");
        System.out.println(p1 == p11); // false
        System.out.println(p1.equals(p11));// false

        //list string
        List<String> list1 = new ArrayList<>();
        list1.add(str1);
        System.out.println("\nList String test:");
        System.out.println(list1.contains(str1));
        System.out.println(list1.contains("aaa"));
        System.out.println(list1.contains(str11));

        //list object
        List<Person> list2 = new ArrayList<>();
        list2.add(p1);
        System.out.println("\nList object test:");
        System.out.println(list2.contains(p1));
        System.out.println(list2.contains(p11));// false
        System.out.println(list2.contains(p2));// false

        //set string
        Set<String> set1 = new HashSet<String>();
        set1.add(str1);
        System.out.println("\nSet String test:");
        System.out.println(set1.contains(str1));
        System.out.println(set1.contains("aaa"));
        System.out.println(set1.contains(str11));

        //set object
        Set<Person> set2 = new HashSet<Person>();
        set2.add(p1);
        System.out.println("\nSet Object test:");
        System.out.println(set2.contains(p1));
        System.out.println(set2.contains(p11));// false
        System.out.println(set2.contains(p2));// false

        //map string
        Map<String,String> map1 = new HashMap<String, String>();
        map1.put(str1, str1);
        System.out.println("\nMap String test:");
        System.out.println(map1.containsKey(str1));
        System.out.println(map1.containsKey(str11));
        System.out.println(map1.containsValue(str1));
        System.out.println(map1.containsValue(str11));

        //map object
        Map<Person,Person> map2 = new HashMap<Person,Person>();
        map2.put(p1,p1);
        System.out.println("\nMap Object test:");
        System.out.println(map2.containsKey(p1));
        System.out.println(map2.containsKey(p11));// false
        System.out.println(map2.containsValue(p1));
        System.out.println(map2.containsValue(p11));// false
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
}

可以看出，String 只要内容相同就被判断为 true

第二波测试

重写Person的equals方法之后的结果：

//注释为false的是错误，没写的是true

import java.util.*;

import javax.print.attribute.HashAttributeSet;

public class contains{
    public static void main(String[] args){

        String str1 = "aaa";
        String str11 = "aaa";
        String str2 = "bbb";

        //string 存储方式，重复字符串不会另行开辟空间
        System.out.println("String storage test:");
        System.out.println(str1 == "aaa");
        System.out.println(str1 == str11);
        System.out.println(str1.equals(str2));// false
        System.out.println(str1.equals("aaa"));

        Person p1 = new Person("A", 1);
        Person p11 = new Person("A", 1);
        Person p2 = new Person("B", 2);

        //new几个就有几个空间
        System.out.println("\nObject storage test");
        System.out.println(p1 == p11); // false
        System.out.println(p1.equals(p11));

        //list string
        List<String> list1 = new ArrayList<>();
        list1.add(str1);
        System.out.println("\nList String test:");
        System.out.println(list1.contains(str1));
        System.out.println(list1.contains("aaa"));
        System.out.println(list1.contains(str11));

        //list object
        List<Person> list2 = new ArrayList<>();
        list2.add(p1);
        System.out.println("\nList object test:");
        System.out.println(list2.contains(p1));
        System.out.println(list2.contains(p11));
        System.out.println(list2.contains(p2));// false

        //set string
        Set<String> set1 = new HashSet<String>();
        set1.add(str1);
        System.out.println("\nSet String test:");
        System.out.println(set1.contains(str1));
        System.out.println(set1.contains("aaa"));
        System.out.println(set1.contains(str11));

        //set object
        Set<Person> set2 = new HashSet<Person>();
        set2.add(p1);
        System.out.println("\nSet Object test:");
        System.out.println(set2.contains(p1));
        System.out.println(set2.contains(p11));// false
        System.out.println(set2.contains(p2));// false

        //map string
        Map<String,String> map1 = new HashMap<String, String>();
        map1.put(str1, str1);
        System.out.println("\nMap String test:");
        System.out.println(map1.containsKey(str1));
        System.out.println(map1.containsKey(str11));
        System.out.println(map1.containsValue(str1));
        System.out.println(map1.containsValue(str11));

        //map object
        Map<Person,Person> map2 = new HashMap<Person,Person>();
        map2.put(p1,p1);
        System.out.println("\nMap Object test:");
        System.out.println(map2.containsKey(p1));
        System.out.println(map2.containsKey(p11));// false
        System.out.println(map2.containsValue(p1));
        System.out.println(map2.containsValue(p11));
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            if (this.getName().equals(((Person)obj).getName())
            &&(this.getAge() == ((Person)obj).getAge())){
                return true;
            }
        }
        return false;
    }
}

不出所料的是，不同的拥有相同内容的Person可以equal，list 的contains 能够识别内容相同的 Person，然而 set 却没有变化 ，map 的 containsValue 能够识别内容相同的 Person，而containsKey 却不能。
这是一个很有趣的结果
原因是，set 和 map 的 containskey 在使用equals的同时，也会使用 hashCode() 方法，因此，两个方法返回都相同时，两个对象才能被视为相等。

第三波测试

重写hashCode() 方法：

//注释为false的是错误，没写的是true

import java.util.*;

import javax.print.attribute.HashAttributeSet;

public class contains{
    public static void main(String[] args){

        String str1 = "aaa";
        String str11 = "aaa";
        String str2 = "bbb";

        //string 存储方式，重复字符串不会另行开辟空间
        System.out.println("String storage test:");
        System.out.println(str1 == "aaa");
        System.out.println(str1 == str11);
        System.out.println(str1.equals(str2));// false
        System.out.println(str1.equals("aaa"));

        Person p1 = new Person("A", 1);
        Person p11 = new Person("A", 1);
        Person p2 = new Person("B", 2);

        //new几个就有几个空间
        System.out.println("\nObject storage test");
        System.out.println(p1 == p11); // false
        System.out.println(p1.equals(p11));

        //list string
        List<String> list1 = new ArrayList<>();
        list1.add(str1);
        System.out.println("\nList String test:");
        System.out.println(list1.contains(str1));
        System.out.println(list1.contains("aaa"));
        System.out.println(list1.contains(str11));

        //list object
        List<Person> list2 = new ArrayList<>();
        list2.add(p1);
        System.out.println("\nList object test:");
        System.out.println(list2.contains(p1));
        System.out.println(list2.contains(p11));
        System.out.println(list2.contains(p2));// false

        //set string
        Set<String> set1 = new HashSet<String>();
        set1.add(str1);
        System.out.println("\nSet String test:");
        System.out.println(set1.contains(str1));
        System.out.println(set1.contains("aaa"));
        System.out.println(set1.contains(str11));

        //set object
        Set<Person> set2 = new HashSet<Person>();
        set2.add(p1);
        System.out.println("\nSet Object test:");
        System.out.println(set2.contains(p1));
        System.out.println(set2.contains(p11));
        System.out.println(set2.contains(p2));// false

        //map string
        Map<String,String> map1 = new HashMap<String, String>();
        map1.put(str1, str1);
        System.out.println("\nMap String test:");
        System.out.println(map1.containsKey(str1));
        System.out.println(map1.containsKey(str11));
        System.out.println(map1.containsValue(str1));
        System.out.println(map1.containsValue(str11));

        //map object
        Map<Person,Person> map2 = new HashMap<Person,Person>();
        map2.put(p1,p1);
        System.out.println("\nMap Object test:");
        System.out.println(map2.containsKey(p1));
        System.out.println(map2.containsKey(p11));
        System.out.println(map2.containsValue(p1));
        System.out.println(map2.containsValue(p11));
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            if (this.getName().equals(((Person)obj).getName())
            &&(this.getAge() == ((Person)obj).getAge())){
                return true;
            }
        }
        return false;
    }
    @Override
    public int hashCode() {
        return this.getAge();
    }
}

结论：set 的contains 和 map 的 containskey 在使用equals的同时，也会先使用 hashCode() 方法，在hashCode 相同的基础上再通过equals 判断是否相同。两个判断都相同时，才认定元素相等，contains 返回 true

后话：之后的学习中也印证了，set 的 contains 使用hashcode 方法判断等价性是因为，上面例子中使用的是 hashset ，也就是，set 的下层实现方式是哈希，所以才会跟 hashcode 扯上关系。同理，map 也因为 hashmap 底层的哈希原理。

G. Albert
关注
专栏目录
java中hashCode方法与equals方法以及contains方法的用法总结
惜忆隐蝶
12-10 3493
一、equals方法的作用    1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。 2 、要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相
如何正确实现 Java 中的 HashCode
weixin_45955969的博客
02-22 521
相等 和 Hash Code 从一般角度来看，Equality 是不错的，但是 hash code 更则具技巧性。如果我们在 hash code上多下点功夫，我们就能了解到 hash code 就是用在细微处去提升性能的。 大部分的数据结构使用equals去检查是否他们包含一个元素。例如： 1 2 List list = Arrays.asList(“a”, “b”, “c”); boolean contains = list.contains(“b”); 这个变量 contains 是true。因为他们是
Java中contains()方法使用的详细解释（源代码解释）
热门推荐
weixin_45690561的博客
05-11 1万+
String类型 List<String> names= new ArrayList<>(); names.add("Jimmy"); names.add("小明"); System.out.println(names.contains("Jimmy")); 输出：true 本段代码 可以看出集合中存在“Jimmy”，运行后代码输出“true”。 contains的方法的实现原理 //调用了ArrayList的contains方法 public boolean ..
【Java】 深入了解 Java util 包中的 contains() 方法
最新发布
2333333
08-11 1011
contains() 方法是 Collection 接口中的一个方法，用于检查集合中是否存在指定的元素。该方法在多个集合类中都有实现，例如 ArrayList、HashSet、LinkedList 等。Java util 包中的 contains() 方法是集合操作中的重要工具，它提供了一种简单而有效的方式来检查集合中是否存在特定元素。无论是在权限验证、防止重复添加元素，还是在文本处理等场景中，contains() 方法都能发挥重要作用。
java contains()与equals()的关系
Jay112011的博客
06-30 1170
java contains()与equals()的关系 我们知道List是一种有序链表：List内部按照放入元素的先后顺序存放，并且每个元素都可以通过索引确定自己的位置。 List还提供了boolean contains(Object o)方法来判断List是否包含某个指定元素。此外，int indexOf(Object o)方法可以返回某个元素的索引，如果元素不存在，就返回-1。 我们来看一个例子： public class Main { public static void mai
Java String类 contains 函数底层算法
weixin_34116110的博客
08-10 1124
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的contains方法
m0_58692733的博客
01-03 5799
3. **效率**：在 `HashSet` 中，`contains` 方法非常高效，因为 `HashSet` 基于哈希表实现。在 Java 中，`contains` 方法是 `Collection` 接口中定义的一个方法，用于检查集合（如 `List`、`Set` 等）是否包含特定的元素。4. **相等性的判断**：`contains` 方法使用元素的 `equals` 方法来判断是否相等。在这个例子中，`containsFive` 会被赋值为 `true`，因为 5 是 `mySet` 集合的一个元素。
带你快速看完9.8分神作《Effective Java》—— 类和接口篇
如切如磋，如琢如磨
01-10 1498
???? Java学习：Java从入门到精通总结 ???? Spring系列推荐：Spring源码解析 ???? 最近更新：2022年1月7日 ???? 个人简介：通信工程本硕????、阿里新晋猿同学????。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤 ???? 点赞 ???? 收藏 ⭐留言 ???? 都是我最大的动力！ 15 使类和成员的可访问性最小化 面向对象语言设计时的两大“法宝”就是封装和解耦。其中，封装可以隐藏组件所有的实现细节，把API与实现清晰隔离开，因此也就解除组成系
Java提高篇——通过分析 JDK 源代码研究 Hash 存储机制
pleaseprintf的博客
05-29 934
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。
基于java的容器底层原理实现
萌萌的PP博客
11-13 8404
一.java容器的体系大览 1. java为啥子需要容器呢? 通常，程序总是在运行时才能确定要创建的对象，甚至是对象的类型。为了解决这个问题，需要在任意时刻任意位置创建任意数量的对象。大多数语言都提供某种方法来解决这个问题，Java使用容器来解决这个问题。容器也称集合类，基本的类型是List、Set、Queue、Map，但由于Java类库中使用了Collection关键字来代表某一接口，所以一般...
Java学废之路06——泛型与集合
我姓弓长那个张的博客
10-27 306
六、泛型与集合 6.1 泛型 为了能够更好的学习容器，我们首先要先来学习一个概念：泛型。 泛型是JDK1.5以后增加的，它可以帮助我们建立类型安全的集合。在使用了泛型的集合中，遍历时不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，提高了代码可读性和安全性。 泛型的本质就是“数据类型的参数化”。泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。使用泛型编写的代码要比那些杂乱的使用Object变量，然后再进行强制类型转换的代码具有更好的安全性，可读性。 6.
String源码阅读之contains实现原理
wei009965的博客
12-26 776
本文将对String部分源码进行阅读分析的记录。 contains 对String中的contains方法进行分析，了解其采用的是什么算法进行匹配。 //用于判断源字符串是否包含目标字符序列 CharSequence s  public boolean contains(CharSequence s) {          //调用indexOf(String str)方法         r...
从HashMap的containsKey入手深入剖析hashcode机制和equals机制
小武的博客
08-14 510
可以看到getNode是核心的方法，所以需要对getNode方法做详细的研究 下图是getNode的逻辑图，有逻辑图就可以很清晰高效的看懂一个方法 但是博客中显示的大小总是被压缩，读者可以点开看大图 我也在探索怎么写最合适 我始终觉得 图形化有利于高效的理解 为此，我要么做自己的博客，把页宽调大，能粘贴图片显示全面一些 也可以考虑直接开发可以显示onenote格式的...
java—— 深入理解contains方法
hjk12345678910的博客
03-30 2042
深入理解contains方法 如下代码： public static void main(String[] args) { Collection c=new ArrayList(); //在集合c中添加两个元素 String s1=new String("abc"); c.add(s1); String s2=new String("def"); c.add(s2); //再次创建String变量，变量名为abc String x=new String("abc");
Java集合的 contains( ) 执行流程
weixin_43960117的博客
11-15 760
Java集合的 contains( ) 执行原理 1 问题描述 想让classID一样的class对象的classTime叠加起来，目前是分开存放在list中 方案： 手动遍历 利用List或者Set的contains( )去重 改成用HashMap存放，key为ID，轻松解决问题 （不过这方法后来才想到） 2 ArrayList的contains 基于ArrayList测试 需要重写equals方法 基于 java 11 ArrayList在contains方法中会调用Arra
List及String类的Contains方法底层源码解析
qq_62693450的博客
01-06 888
原理其实就是通过IndexOf方法去匹配是否存在。如果存在则返回True，反则False
List和Set的contains()方法实现原理
diweikang的博客
09-08 1万+
新手对Set中contains()方法的疑惑 class Dog { int id; String color; public Dog(int id, String color) { this.id = id; this.color = color; } public int getId() { return id; } public void setId(i...
String.contains()方法
qq_48651829的博客
11-28 4953
关于String的方法String.contains()。
JAVA基础：contains和remove执行原理、List、Set的区别及应用
T_Tonz的博客
07-09 687
contains和remove contians和remove操作自定义对象时候，其实底层是用equals去比较对象，需要重写equals 方法，然后当传入同一个对象时候，才会返回true，否则就是false 对象数组(引用数组)：对象数组指的就是存储引用数据类型的数组 /* 对象数组 引用数组 / public class ObjArray { public static void main(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值