HashMap的底层实现原理biubiubiu

最新推荐文章于 2024-07-05 14:45:08 发布

Mr.晨光

最新推荐文章于 2024-07-05 14:45:08 发布

阅读量193

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_46982142/article/details/107297605

版权

HashMap的实现原理和底层结构

哈希表

哈希表也叫散列表，是一种重要的数据结构，应用场景比较丰富。

和其他的数据结构相比，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。

哈希表的主干是数组

假如我们要查找某个元素的关键字，可以通过函数映射带数组中的某个位置，这个函数就是hash函数

哈希冲突

如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。

HashMap实现原理

HashMap的主干是一个数组,每一个Entry都抱一个键值对<key,value>

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

然后我们打开原码可以看到，Entry是一个静态内部类，实现了Map接口。

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

我们都知道HashMap是由数组和链表组成的，数组是主体，链表是为了解决哈希冲突的。

如果定位道德数组位置不含有链表的话，添加和查找操作只需要一次就可以。

反之，如果头部已经有了，那我们通过遍历操作通过equals方法比较key

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CIPNGUjn-1594526884442)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200712114534948.png)]

初始容量默认是16，加载因子是0.75

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

从上面这段代码我们可以看出，在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组

put的实现

public void put(Object key, Object value) {
		//判断是否存在数组,如果不存在创建
		if(table == null||table.length == 0) {
			table = new Node[16];
		}
		
		//1.计算位桶索引  hash
		int hash = hash(key.hashCode());
		
		//2.构建新节点
		Node newNode = new Node(hash,key,value,null);
		
		//3.获取数组中对应索引位置的节点-->首节点
		Node node = table[hash];
		
		//4.判断节点是否存在,不存在直接添加作为链表头节点,
		if(node == null) {
			table[hash] = newNode;
			size++;
		}else {
			//5.存在就遍历,找到最后节点
			while(true) {
				//从第一个节点快开始,先判断key与添加新节点的key是否相同,相同覆盖,不相同才往后遍历
				if(node.getKey().equals(key)) {
					node.setValue(value);
					return;
				}
				if(node.getNext()==null) {
					break;
				}
				node = node.getNext();
			}
			//添加新节点
			node.setNext(newNode);
			//6.size++
			size++;
		}
		
	}

hash函数

//计算位桶索引的hash
	public int hash(int hashcode) {
		return hashcode & (table.length-1);  //保证数组的长度为2的整数幂   %->除法效率较低   &->位运算符效率高
	}

看看源码

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

通过hash函数获得的值来处理具体的位置

  static int indexFor(int h, int length) {
        return h & (length-1);
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YgYaTLgm-1594526884445)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200712120415569.png)]

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

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