Java HashMap的实现

最新推荐文章于 2023-05-15 14:53:36 发布
最新推荐文章于 2023-05-15 14:53:36 发布
阅读量3k 收藏
点赞数
分类专栏： java algorithm 文章标签： hashmap java map algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hooting/article/details/39924567
版权

HashMap是Java中经常使用的集合类。HashMap的每个元素是一个<Key,Value>键值对，在内部用数组来保存每个元素，hash函数将Key作为参数，计算出Value的存储位置，即数组的下标。实现HashMap，关键在于找到一个hash函数，使其尽量少的发生冲突。那么，何为冲突？如下图所示，


当值“F"插入HashMap集合时，发现他所对应的位置已有数据插入，此时便发生了冲突。解决冲突的办法这里列举三种：linear probing, double hashing, 和chaining。


linear probing方法

linear probing解决冲突的方式是：当冲突发生，后来的数据依次往后寻找空闲位置，一旦找到，便插入。如下图所示：



当值"F"插入时，因为原有位置已被"D"占领，则依次往后查找，在值"C"之后发现空闲位置并插入。查找到数组的尾部时，返回到头部继续查找，如下图所示：


如果查找到本应输入的位置，依旧没有可插入的位置，说明hashmap存满，如下图所示：


类HashMapNode表示HashMap中的每个元素，它主要有两个成员：Key和Value。实现如下：

public class HashMapNode {
	private Object key;
	private Object value;
	// construction
	public HashMapNode(Object key, Object value){
		this.key = key;
		this.value = value;
	}
	// get methods
	public Object getKey(){
		return key;
	}
	public Object getValue(){
		return value;
	}
	// set method
	public void setValue(Object newValue){
		this.value = newValue;
	}
}


类HashMap是采用linear probing方式的hashmap实现，具体如下：

import java.util.ArrayList;
import java.util.List;

public class HashMap<K, V> {
  private int multiplier;
  private int modulus;
  private int hashMapSize;//HashMap容量
  private HashMapNode[] array;
  private int size = 0;//HashMap现有元素个数

  
  // construction
  // construct a HashMap with 4000 places and given hash paarameters
  public HashMap(int multiplier, int modulus){
    this.multiplier = multiplier;
    this.modulus = modulus;
    this.hashMapSize = 4000;
    this.array = new HashMapNode[this.hashMapSize];
  }
  
   // construct a HashMap with given capacity and given hash parameters
  public HashMap(int hashMapSize, int multiplier, int modulus){
    this.multiplier = multiplier;
    this.modulus = modulus;
    this.hashMapSize = hashMapSize;
    this.array = new HashMapNode[this.hashMapSize];
  }
 
  // hashing
  public int hash(K key){
    return Math.abs(multiplier * key.hashCode()) % modulus % this.hashMapSize;
  }
  
  // size
  public int size(){
    return size;
  }
  
  // return the number of nodes currently stored in the map
  public boolean isEmpty(){
    return size == 0;
  }
  
  // interface methods
  @SuppressWarnings("unchecked")
  public List<K> keys(){
    List<K> list = new ArrayList<K>();
    for(int i = 0; i < this.hashMapSize; i++){
      if(array[i] != null){
        list.add((K)array[i].getKey());
      }
    }
    return list;
  }
  
  @SuppressWarnings("unchecked")
  public V put(K key, V value){
    int hashCode = hash(key);//hashCode是value本应存放的位置
    if(array[hashCode] == null){//该位置是空的，则直接放入，不需要处理冲突
      HashMapNode node = new HashMapNode(key,value);
      array[hashCode] = node;
      size++;
      return null;
    }else if(key.equals((K)array[hashCode].getKey())){//该主键已存在，则更新对应的值
      V oldValue = (V)array[hashCode].getValue();
      array[hashCode].setValue(value);
      return oldValue;
    }
    int probe = (hashCode + 1) % this.hashMapSize;//开始处理冲突
    while(probe != hashCode){
      if(array[probe] == null){//找到空闲位置
        HashMapNode node = new HashMapNode(key,value);
        array[probe] = node;
        size++;
        return null;
      }else if(key.equals((K)array[probe].getKey())){//该主键已存在，则更新对应的值
        V oldValue = (V)array[probe].getValue();
        array[probe].setValue(value);
        return oldValue;
      }else{
        probe = (probe + 1) % this.hashMapSize;
      }
    }
    return null;
  }

  @SuppressWarnings("unchecked")
  public V get(K key){
    int hashCode = hash(key);
    if(array[hashCode] != null && key.equals((K)array[hashCode].getKey())){
      return (V)array[hashCode].getValue();
    }
    int probe = (hashCode + 1) % this.hashMapSize;
    while(probe != hashCode){//依次往后查找，直到回到原点
      if(array[probe] == null){
        probe = (probe + 1) % this.hashMapSize;
        continue;
      }else if(key.equals((K)array[probe].getKey())){
        return (V)array[probe].getValue();
      }else{
        probe = (probe + 1) % this.hashMapSize;
      }
    }
    return null;
  }

  @SuppressWarnings("unchecked")
  public V remove(K key){
    int hashCode = hash(key);
    if(array[hashCode] != null && key.equals((K)array[hashCode].getKey())){
        V oldValue = (V)array[hashCode].getValue();
        array[hashCode] = null;//该位置设置为null，表示被删除
        size--;
        return oldValue;
    }
    int probe = (hashCode + 1) % this.hashMapSize;
    while(probe != hashCode){
      if(array[probe] == null){
        probe = (probe + 1) % this.hashMapSize;
        continue;
      }else if(key.equals((K)array[probe].getKey())){
        V oldValue = (V)array[probe].getValue();
        array[probe] = null;
        size--;
        return oldValue;
      }else{
        probe = (probe + 1) % this.hashMapSize;
      }
    }
    return null;
  }
}

double hashing 方法

double hashing方法，思想是当发生冲突时，结合第二个hash函数，新生成一个hashCode，直到不发生冲突为止。此处使用的第二个hash函数如下：secondaryModulus   (abs(hashCode(key)) mod secondaryModulus)，计算元素下标值的方法如下：hash(key) + j * secondary(key)。j从0开始逐渐递增，直到不冲突为止。具体实现如下：

import java.util.ArrayList;
import java.util.List;

public class DoubleHashMap<K, V> {
	private int multiplier;
	private int modulus;
	private int secondaryModulus;
	private int hashMapSize;
	private HashMapNode[] array;
	private int size = 0;
	
	// construction
	// construct a HashMap with 4000 places and given hash paarameters
	public DoubleHashMap(int multiplier, int modulus, int secondaryModulus){
		this.multiplier = multiplier;
		this.modulus = modulus;
		this.secondaryModulus = secondaryModulus;
		this.hashMapSize = 4000;
		this.array = new HashMapNode[this.hashMapSize];
	}
	
	// construct a HashMap with given capacity and given hash parameters
	public DoubleHashMap(int hashMapSize, int multiplier, int modulus, int secondaryModulus){
		this.multiplier = multiplier;
		this.modulus = modulus;
		this.secondaryModulus = secondaryModulus;
		this.hashMapSize = hashMapSize;
		this.array = new HashMapNode[this.hashMapSize];
	}
	
	// hashing
	public int hash(K key){
		return Math.abs(multiplier * key.hashCode()) % modulus;
	}
	
	public int secondaryHash(K key){
		return this.secondaryModulus - Math.abs(key.hashCode()) % this.secondaryModulus;
	}
	
	// size
	public int size(){
		return size;
	}
	// return the number of nodes currently stored in the map
	public boolean isEmpty(){
		return size == 0;
	}
	
	// interface methods
	@SuppressWarnings("unchecked")
	public List<K> keys(){
		List<K> list = new ArrayList<K>();
		for(int i = 0; i < this.hashMapSize; i++){
			if(array[i] != null){
				list.add((K)array[i].getKey());
			}
		}
		return list;
	}
	
	@SuppressWarnings("unchecked")
	public V put(K key, V value){
		int hashCode = hash(key);//calculating the hash code
		if(array[hashCode % this.hashMapSize] == null){//if the hash item is empty, add the data straight away
			HashMapNode node = new HashMapNode(key,value);
			array[hashCode % this.hashMapSize] = node;
			size++;
			return null;
		}else if(key.equals((K)array[hashCode % this.hashMapSize].getKey())){
			V oldValue = (V)array[hashCode % this.hashMapSize].getValue();
			array[hashCode % this.hashMapSize].setValue(value);
			return oldValue;
		}

		int secondHashCode = secondaryHash(key);
		int probe = 0;//variable to store probing location
		int j = 0;
		V retValue = null;
		while(true){
			j++;
			probe = (hashCode + j * secondHashCode) % this.hashMapSize;
			if(array[probe] == null){
				HashMapNode node = new HashMapNode(key,value);
				array[probe] = node;
				size++;
				break;
			}else if(key.equals((K)array[probe].getKey())){
				retValue = (V)array[probe].getValue();
				array[probe].setValue(value);
				break;
			}
		}
		return retValue;
	}

	@SuppressWarnings("unchecked")
	public V get(K key){
		int hashCode = hash(key) % this.hashMapSize;
		if(array[hashCode] != null && key.equals((K)array[hashCode].getKey())){
			return (V)array[hashCode].getValue();
		}
		int probe = (hashCode + 1) % this.hashMapSize;
		while(probe != hashCode){
			if(array[probe] == null){
				probe = (probe + 1) % this.hashMapSize;
				continue;
			}else if(key.equals((K)array[probe].getKey())){
				return (V)array[probe].getValue();
			}else{
				probe = (probe + 1) % this.hashMapSize;
			}
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public V remove(K key){
		int hashCode = hash(key) % this.hashMapSize;
		if(array[hashCode] != null && key.equals((K)array[hashCode].getKey())){
				V oldValue = (V)array[hashCode].getValue();
				array[hashCode] = null;
				size--;
				return oldValue;
		}
		int probe = (hashCode + 1) % this.hashMapSize;
		while(probe != hashCode){
			if(array[probe] == null){
				probe = (probe + 1) % this.hashMapSize;
				continue;
			}else if(key.equals((K)array[probe].getKey())){
				V oldValue = (V)array[probe].getValue();
				array[probe] = null;
				size--;
				return oldValue;
			}else{
				probe = (probe + 1) % this.hashMapSize;
			}
		}
		return null;
	}
	
}

chaining 方法

chaining方法的核心思想是，当发生冲突时，将冲突的元素用链表的形式连接起来，如下图所示：


ChainingHashMap类表示每个元素，具体实现如下：

public class ChainingHashMapNode {
	private Object key;
	private Object value;
	private ChainingHashMapNode next;
	// construction
	public ChainingHashMapNode(Object key, Object value){
		this.key = key;
		this.value = value;
		this.next = null;
	}
	// get methods
	public Object getKey(){
		return key;
	}
	public Object getValue(){
		return value;
	}
	public ChainingHashMapNode getNext(){
		return next;
	}
	// set methods
	public void setValue(Object newValue){
		this.value = newValue;
	}
	public void setNext(ChainingHashMapNode next){
		this.next = next;
	}
}


使用chaining方法的HashMap实现如下： 

import java.util.ArrayList;
import java.util.List;

public class ChainingHashMap<K, V> {
	private int multiplier;
	private int modulus;
	private ChainingHashMapNode[] array;
	private int hashMapSize;
	private int size;
	
	// construction
	// construct a HashMap with 4000 places and given hash parameters
	public ChainingHashMap(int multiplier, int modulus){
		this.multiplier = multiplier;
		this.modulus = modulus;
		this.hashMapSize = 4000;
		this.array = new ChainingHashMapNode[this.hashMapSize];
		this.size = 0;
	}

	// construct a HashMap with given capacity and given hash parameters
	// hashing
	public ChainingHashMap(int hashMapSize, int multiplier, int modulus){
		this.multiplier = multiplier;
		this.modulus = modulus;
		this.hashMapSize = hashMapSize;
		this.array = new ChainingHashMapNode[this.hashMapSize];
		this.size = 0;
	}

	public int hash(K key){
		return Math.abs(multiplier * key.hashCode()) % modulus  % this.hashMapSize;
	}
	// size
	public int size(){
		return size;
	}
	// return the number of nodes currently stored in the map
	public boolean isEmpty(){
		return size == 0;
	}
	// interface
	
	
	@SuppressWarnings("unchecked")
	public List<K> keys(){
		List<K> list = new ArrayList<K>();
		for(int i = 0; i < this.hashMapSize; i++){
			ChainingHashMapNode node = array[i];
			while(node != null){
				list.add((K)node.getKey());
				node = node.getNext();
			}
		}
		return list;
	}
	
	@SuppressWarnings("unchecked")
	public V put(K key, V value){
		int hashCode = hash(key);
		if(array[hashCode] == null){//没有发生冲突，放入首位
			ChainingHashMapNode node = new ChainingHashMapNode(key,value);
			array[hashCode] = node;
			size++;
			return null;
		}
		ChainingHashMapNode node = array[hashCode];
		ChainingHashMapNode pre = node;
		while(node != null){
			if(key.equals((K)node.getKey())){//已存在Key，更新值
				V oldValue = (V)node.getValue();
				node.setValue(value);
				return oldValue;
			}else{
				pre = node;
				node = node.getNext();
			}
		}
		ChainingHashMapNode newNode = new ChainingHashMapNode(key,value); //在链表末尾添加冲突的元素
		pre.setNext(newNode);
		size++;
		return null;
	}

	@SuppressWarnings("unchecked")
	public V get(K key){
		int hashCode = hash(key);
		ChainingHashMapNode node = array[hashCode];
		while(node != null){
			if(key.equals((K)node.getKey())){
				return (V)node.getValue();
			}else{
				node = node.getNext();
			}
		}
		return null;
	}
	@SuppressWarnings("unchecked")
	public V remove(K key){
		int hashCode = hash(key);
		ChainingHashMapNode node = array[hashCode];
		if(node != null && key.equals((K)node.getKey())){
			array[hashCode] = node.getNext();
			size--;
			return (V)node.getValue();
		}
		ChainingHashMapNode pre = node;
		node = node.getNext();
		while(node != null){
			if(key.equals((K)node.getKey())){
				pre.setNext(node.getNext());
				size--;
				return (V)node.getValue();
			}else{
				pre = node;
				node = node.getNext();
			}
		}
		return null;
	}
}

参考： http://www.cs.rmit.edu.au/online/blackboard/chapter/05/documents/contribute/chapter/05/linear-probing.html

Hooting
关注
专栏目录
Java中的集合（2）—— HashMap原理及用法 & ~ &
fsjdgfcuvb的博客
11-17 372
一、首先，先搞清楚hashCode和equals两者： 1、关于hashCode （1）、hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的 （2）、如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同 （3）、如果对象的e...
深入解析java HashMap实现原理
09-03
Java中的HashMap是一个非常重要的数据结构，它实现了Map接口，提供了高效的数据存储和检索功能。HashMap的核心实现基于哈希表，其内部数据结构是数组与链表的结合，也就是所谓的“链表散列”结构。 1. **HashMap...
Java之七：HashMap的实现原理
Evan的开源之旅
07-20 732
1.    HashMap概述：    HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。   2.    HashMap的数据结构：    在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本
Java中HashMap的实现
cxp863的博客
04-14 308
HashMap是如何实现的？ 简单说，HashMap是通过一个数组和多个链表实现的。数组用来记录key，链表用来构成桶（键值对链表）。 注意：桶是指的数组，不是链表。 put()函数： 对key的hashcode再次进行hash（高16位和低16位进行异或得到），计算index 去数组的index位置找，尝试挂到数组index位置的链表里面。这时候会调用key.equals()函数，如果...
JAVA-HashMap的具体实现
m0_56161893的博客
03-17 802
HashMap的具体实现和存储方式，以及put方法的具体实现流程
java实现hashmap_Java的HashMap实现
weixin_26737625的博客
09-08 584
java实现hashmapHashMap is a dictionary data structure provided by java. It’s a Map-based collection class that is used to store data in Key & Value pairs. In this article, we’ll be creating our own ...
详解Java HashMap实现原理
08-31
以下是对HashMap实现原理的详细解析。 首先，HashMap内部使用了一个瞬时变量数组`table`（也称为“桶”）来存储键值对。桶是一个Entry对象数组，它的大小可以动态调整，并且长度必须是2的幂。初始时，`table`是一个...
Java HashMap实现原理分析（一）
09-07
总的来说，Java HashMap的实现原理主要包括以下几个关键点： 1. 基于哈希表的数据结构，使用数组+链表的方式存储键值对。 2. 使用键的哈希值计算数组索引，通过异或和位移操作优化哈希分布。 3. 链地址法解决哈希...
Java8 HashMap的实现原理分析
09-02
Java8之后新增挺多新东西，接下来通过本文给大家介绍Java8 HashMap的实现原理分析，对java8 hashmap实现原理相关知识感兴趣的朋友一起学习吧
Java HashMap实现原理详解：数组+链表的巧妙结合
总结来说，HashMap通过巧妙地结合数组和链表，实现了快速查找、灵活扩容以及处理哈希冲突的能力，是Java中常用的数据结构之一，适用于需要高效查找和插入操作的场景。理解其内部实现机制对于编写高效代码至关重要。
Java_HashMap实现原理
qiangzai110110的博客
04-28 247
四种数据存储结构 1、顺序存储：在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。 如：内存中连继地址对应的存储着数据元素 连续内存地址 数据元素 OX0001 Jack OX0010 Rose OX0011 Petter OX0100 John 特点： 1、随机存取表中元素。 2、插入和删除操作需要移动元素。 2、链接存储...
java中HashMap的实现原理介绍
qq_32067151的博客
11-05 523
hash表的存储原理： 1.我们知道，hash表存储利用到了数组以及链表，当键值对数据传入时，系统先将key值取出，利用hash函数转换成hash值，再运用散列法（此处用除法散列法取余），得到需要存入数组的下标index； 2.得到数组下标后，我们可以将key-value一起存入到数组中; 3.当使用index进行存储键值对的时候，如果此下标已经有了数据，那么将通过equals方...
Java HashMap详解及实现原理
最新发布
兴趣是最好的老师，勤能补拙
05-15 2183
Java HashMap是Java集合框架中最常用的实现Map接口的数据结构，它使用哈希表实现，允许null作为键和值，可以存储不同类型的键值对。HashMap提供了高效的存取方法，并且是非线程安全的。在Java中，HashMap被广泛应用于各种场景，如缓存、数据库连接池、路由器等。
java hashmap实现思路
global_coding的博客
02-13 247
hashmap
java中HashMap的实现方式
fdimaof的专栏
06-04 782
<br />HashMap可谓JDK的一大实用工具，把各个Object映射起来，实现了“键－－值”对应的快速存取。但实际里面做了些什么 呢？ <br /><br /> 　 　在这之前，先介绍一下负载因子和容量的属性。大家都知道其实一个 HashMap 的实际容量就 因子*容量，其默认值是 16×0.75＝12； 这个很重要，对效率很一定影响！当存入HashMap的对象超过这个容量时，HashMap 就会重新构造存取表。这就是一个大问题，我后面慢慢介绍，反正，如果你已经知道你大概要存放多少个对象，最
Java中HashMap的实现原理
everxs的博客
08-06 274
最近公司解散了，找工作期间无聊，写写博客。解读一下jdk1.8中HashMap的源码。如有解析不对，欢迎评论指教 作者：郑嘉裕 微信：vn1906(欢迎博客好友共同探讨技术问题) HashMap设计思路： 1、简单分析数组跟链表：先从数组跟链表讲起吧，数组的遍历为什么快？链表的遍历为什么慢？这里就再解释一下，因为数组是基于下标查询的，比如int a[] = {1，2，3，4，5}， 你要...
HashMap是什么
weixin_43410352的博客
03-24 618
网上有篇博文总结得很好，始终贯彻避免重复造轮子，我就直接引用这篇博客了。。。。 原文地址：https://www.cnblogs.com/chengxiao/p/6059914.html 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中HashMap的实...
Java HashMap的实现原理
yang's space
11-21 220
HashMap HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。HashMap数组每一个元素的初始值都是Null。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值