HashSet、HashMap

最新推荐文章于 2024-05-20 14:36:25 发布
最新推荐文章于 2024-05-20 14:36:25 发布
阅读量211 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34983808/article/details/78662309
本文深入解析了HashSet如何基于HashMap实现元素的添加与查找操作。详细分析了HashMap内部的工作机制，包括hash值的计算、节点的存储及扩容过程，并通过具体示例展示了不同情况下的元素比较逻辑。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

HashSet添加元素方法的本质也是调用HashMap
这里写图片描述

HashMap实现原理：
移位、^运算=hash值
能否添加进HashMap集合当中呢？
3个依据：判断hash值、是否为同一对象、equals方法是否相等
e.hash == hash && ((k = e.key) == key || key.equals(k))

Entry<K,V> e = table[i]; e != null; e = e.next
//取桶里的对象，如果桶里没有对象即立刻添加进来,如果有需要，可以进行桶的扩容
void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }


  void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
Entry<K,V> e = table[i]取桶里的对象，如果桶里没有对象即立刻添加进来，如果有对象则判断桶里的hash值是否等于要放进桶里的对象的hash值，如果相等，再判断是否为同一个对象。

Entry<K,V> e = table[i]取桶里的对象，判断桶里的hash值和将要放进桶里的对象的hash值是否相等，如相等，再判断是否为同一个对象，根据(k = e.key) == key的key值来做判断，如果为同一个对象，说明桶里已经存在该key则为同一个对象， V oldValue = e.value即用药放进桶里的value值取代原来桶里的value值。

Entry<K,V> e = table[i]即用来取桶里的元素，有可能存在，也有可能不存在，如果hash值一样即e.hash == hash为true，但是(k = e.key) == key 为false，说明不是同一个对象。再判断key.equals(k)即判断该对象的equals方法是否相等。如果相等， V oldValue = e.value即用药放进桶里的value值取代原来桶里的value值。
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);  //计算新hash
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

int hash(key)=原hash移位得到新hash并和原hash进行^异或运算

  final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

e = e.next创建新节点

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

===================================

判断HashSet集合是否已经存在某个对象
代码：

package com.zbiti.java;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

    }


    @Test
    public void test1(){
        Set<Dog> dogs = new HashSet<Dog>();
        dogs.add(new Dog("white"));
        dogs.add(new Dog("white"));


        System.out.println(dogs.contains(new Dog("white")));    //fasle
    }
}


class Dog{
    private String name;
    public Dog(String name) {
        this.name = name;
    }

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

结果：输出false
原因：HashSet的contains方法的实现如下：

 public boolean contains(Object o) {
        return map.containsKey(o);
    }
 public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }
 final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

解读：

int hash = (key == null) ? 0 : hash(key);
先判断添加方法里是否有对象，如果有对象计算出新hash值，
 for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null;e = e.next)
 先判断桶里是否有对象，如果有对象取出对象
 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
   return e;
    return null;
   判断hash值是否相等，即放进桶里对象和已经存在桶里对象的hash值是否相等。如不想等，返回null，说明桶里不存在该对象。
   如相等，再判断对象是否为同一个对象。
   如果是同一对象，返回该对象。
   如果不是同一个对象，再判断对象的equals是否相等，即桶里的对象和将要放进桶里的对象的equals方法的比较。

代码：

package com.zbiti.java;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

    }


    @Test
    public void test1(){
        Set<Dog> dogs = new HashSet<Dog>();
        dogs.add(new Dog("white"));
        dogs.add(new Dog("white"));


        System.out.println(dogs.contains(new Dog("white")));  //false
    }
}


class Dog{
    private String name;
    public Dog(String name) {
        this.name = name;
    }

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

    @Override
    public int hashCode() {
        return 1;
    }
}

结果：输出false
分析：Dog类的hashCode方法被我们重写了，根据上面的分析，桶里2只dog和contains里的dog的hash值是一样的都为1,。所以需要再判断是否 为同一个对象，明显通过new 产生了新的对象，所以并不是同一个对象。直接返回了null。

代码：

package com.zbiti.java;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

    }


    @Test
    public void test1(){
        Set<Dog> dogs = new HashSet<Dog>();
        Dog d1 = new Dog("white");
        Dog d2 = new Dog("white");
        dogs.add(d1);
        dogs.add(d2);


        System.out.println(dogs.contains(new Dog("white")));  //true
    }
}


class Dog{
    private String name;
    public Dog(String name) {
        this.name = name;
    }

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

    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

结果：输出true
分析：桶里含有2个Dog对象，HashSet调用contains方法传进了一个新的Dog对象，由于Dog类里的hashcode、equals方法都被我们重写了，所以不管创建多少个对象，它们调用hashcode、equals方法的返回值都是一样的。根据HashMap的实现原理判断的3个原则，hash值相等，尽管对象不一样，但是equals返回值相等即说明桶里存在该对象。

代码：

package com.zbiti.java;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

    }


    @Test
    public void test1(){
        Set<Dog> dogs = new HashSet<Dog>();
        Dog d1 = new Dog("white");
        Dog d2 = new Dog("white");
        dogs.add(d1);
        dogs.add(d2);


        System.out.println(dogs.contains(new Dog("white")));  //false
    }
}


class Dog{
    private String name;
    public Dog(String name) {
        this.name = name;
    }

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

    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public boolean equals(Object obj) {
        return false;
    }
}

结果：输出false
分析：Dog类hashcode()、equals()被我们重写，调用hashcode返回的值是相等的，由于对象不是同一个对象并且调用equals方法返回false，所以输出的结果为false。

代码：

package com.zbiti.java;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

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

    }


    @Test
    public void test1(){
        Set<Dog> dogs = new HashSet<Dog>();
        Dog d1 = new Dog("white");
        Dog d2 = new Dog("white");
        dogs.add(d1);
        dogs.add(d2);


        System.out.println(dogs.contains(d1));
    }   //true
}


class Dog{
    private String name;
    public Dog(String name) {
        this.name = name;
    }

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

    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public boolean equals(Object obj) {
        return false;
    }
}

结果：输出true
分析：Dog类hashcode()、equals()被我们重写，调用hashcode返回的值是相等的,由于桶里的对象存在和将要放进桶里的对象是同一个对象,尽管调用equals方法返回false，结果的输出依然为true。

【数据结构】HashMap和HashSet
拼命阿紫冲冲冲！
04-06 1892
本期主要讲解：1、HashMap 1.1 HashMap的简介 1.2 HashMap 部分源码 1.2.1 HashMap 属性 1.2.2哈希表的构造方法 1.2.3 HashMap 方法 2、HashSet
HashSet和HashMap
冷兮雪的博客
11-21 3361
HashMap集合是 Map接口的一个实现类,它用于存储键值映射关系,该集合的键和值允许为空,但键不能重复且集合中的元素是无序的。HashMap底层是由哈希表结构组成的,其实就是“数组＋链表”的组合体,数组是HashMap的主体结构,链表则主要是为了解决哈希值冲突而存在的分支结构。正因为这样特殊的存储结构,HashMap集合对于元素的增、删、改、查操作表现出的效率都比较高。水平方向以数组结构为主体并在竖直方向以链表结构进行结合的就是 HashMap中的哈希表结构。
如何使用Objects类简单重写equals方法
Wcg_2250365480的博客
11-22 376
如何使用Objects类简单重写equals方法 equals()方法和hashCode()方法是什么？ equals()和hashCode()都是Object类中的方法。 equals方法用于比较两个对象是否相同； hashCode方法是根据对象的地址或者字符串或者数字计算该对象的哈希值 为什么要重写equals() Object类中的equals方法比较的是两个对象的引用地址，只有对象的引用地址指向同一个地址时，才认为这两个对象相等，否则认为不相等。 如果有两个对象，我们需要判断其属性是否相等，那么默
HashMap和HashSet的用法
qq_27752831的博客
05-04 471
/*{“D:\aa\bb\cc.exe”, “E:\aa\bb\cc.txt”, “E:\aa\ee\cc.txt”, “F:\bb\cc.ppt”, “D:\aa\bb\cc.txt”, “E:\aa\bb\cc.xls”, “C:\aa\bb\cc.exe”} 1） 统计出以上的数组中，有多少个盘符。（如C盘，E盘） 2） 统计出有多少个文件类型。 */ package Te
Hash详解+java实现Hashmap Hashset
贤yu的博客
03-11 280
哈希 基本概念 若关键字为k，则其值存放在F(k)的存储位置上。由此，不需要比较便可直接取得所查记录。称这个对应关系F为散列函数，按这个思想建立 的表称为散列表。 存在F(k1)=F(k2)称为冲突，java中用来处理冲突的方法为拉链法（Java源码的hashmap功能强大的多：可根据负载因子自动扩容，处理冲突的方法多） 关于map,set 存入Set的每个元素都必须是唯一的，因为Set不保存重复...
HashMap和HashSet
qq_64438318的博客
07-24 290
HashMap和HashSet
hashset hashmap
09-02
HashSet和HashMap都是Java集合框架中的容器类，它们之间有一些区别。 HashSet是基于HashMap实现的，它只存储了key，并且key不会重复，使用HashSet可以达到去重的效果。在HashSet内部，它的元素是无序的，因为它是...
java hashset hashmap
09-25
HashSet 和 HashMap 是 Java 中的两个常用集合类。 HashSet 是基于哈希表实现的，它继承自 AbstractSet 并且实现了 Set 接口。HashSet 是一个无序的集合，它不允许重复元素。当我们向 HashSet 中添加元素时，它会...
hashset hashmap treeset treemap
最新发布
11-01
哈希集合（HashSet）和哈希映射（HashMap）是数据结构中常见的两个类型，它们都基于哈希表实现。 1. HashSet：它是一个无序的不包含重复元素的集合，通过散列函数将元素存储在数组中。插入、删除和查找操作的时间...
java中关于HashSet、HashMap 和 Hashtable的面试题总结
程序员诚哥
05-20 1050
实现了高效的键值对存储和查找，平均情况下插入、删除和查找操作的时间复杂度为O(1)。方法），然后将元素存储在哈希表的对应位置上。如果该位置已经有元素存储，新增流程主要涉及计算哈希值、定位桶位置、插入节点等步骤。可以实现在常数时间复杂度内向哈希表中插入新的键值对。认为新元素重复，不会将新元素添加进去。方法来比较新元素和已存在元素是否相等。如果不需要考虑线程安全性，并且需要支持。会首先计算元素的哈希码（通过调用元素的。的使用已经不推荐，通常建议使用。需要注意的是，为了正确保证。无法正确判断元素是否重复。
HashMap与HashTable和HashSet的区别
04-23
HashTable不支持空键值对！而HashMap支持空键值对！
Java数据结构学习DAY8——搜索树和哈希表（一）
graceyun的博客
03-29 333
搜索树和哈希表Map和Set 1.搜索 1.1 概念及场景 Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。 以前常见的搜索方式有： 1)直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢; 2)二分查找，时间复杂度为O(log2N)O(log_2N)O(log2​N),但搜索前必须要求序列是有序的. 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： 1)根据姓名查询考试成绩 2)通讯录，即根据姓名查询联系方式
一文带你读懂HashMap和HashSet
m0_51435111的博客
07-16 1000
文章目录集合类体系结构Set集合Map集合模型Map接口常见子类添加问题 集合类体系结构 Set集合Map集合 数据结构:二分搜索树(BST) Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关 时间复杂度:O(logn) 模型 纯key模型 查询某个英文单词在不在字典中 key-value模型 统计每个单词出现的次数<单词,出现次数> Set就是只储存key,Map中储存key-value键值对. Set集合保存的元素不可重复,一般用于
[java]HashMap和HashSet的区别?
ccsky001的天空
05-21 1519
HashSet实现Collection，HashMap和Hashtable实现Map,后者是关键字、值对的形式；Hashtable线程安全，HashMap则不是，另外，HashMap可以有null。
HashMap和HashSet的认识、基本使用
zhikanjiani的博客
08-14 2193
HashMap、HashSet认识 HashMap、HashTable认识 HashMap、HashSet的基本使用 HashTable的用法 “Usage of API documented as @since 1.8+”报错的解决办法 HashMap、HashSet认识 HashSet实现了set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将随想存储在Hash...
HashMap和HashSet的区别
热门推荐
男人放得下自己的高傲，才能撑得起自己的野心
11-30 4万+
1、为什么用HashMap？ HashMap是一个散列桶（数组和链表），它存储的内容是键值对(key-value)映射 HashMap采用了数组和链表的数据结构，能在查询和修改方便继承了数组的线性查找和链表的寻址修改 HashMap是非synchronized，所以HashMap很快 HashMap可以接受null键和值，而Hashtable则不能（原因就是equlas()方法需要对象，因...
HashMap和HashSet的内部工作机制
lxlmycsdnfree的博客
04-02 609
java 的比较基础的功底就是对于java的集合类底层实现和原理的掌握！！！（不可轻视）-----------------------------------------------hashmap存储原理-------------------------------------------案例代码： HashMap hashMap = new HashMap();//line1 h...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值