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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java通过hashMap实现树结构
qq_45735918的博客
08-02 1066
该博文主要讲解java如何使用hashMap来构建一个多叉树(类似mysql索引的 B树类型)并实现关键字识别的功能。 一：什么是B树 B树（B-tree）是有Bayer和McCreight在1972年提出的数据结构。B树索引是数据库中存取和查找文件(称为记录或键值)的一种方法，应用于磁盘读取方面。 B树（B-tree）是一种树状数据结构，它能够存储数据、对其进行排序并允许以O(log n)的时间复杂度运行进行查找、顺序读取、插入和删除的数据结构。B树，概括来说是一个节点可以拥有多于2个子节点的二叉查找树
详解Java HashMap实现原理
08-31
以下是对HashMap实现原理的详细解析。 首先，HashMap内部使用了一个瞬时变量数组`table`（也称为“桶”）来存储键值对。桶是一个Entry对象数组，它的大小可以动态调整，并且长度必须是2的幂。初始时，`table`是一个...
Java HashMap实现详解
lixinxiaos的博客
04-02 2269
1. HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 2. HashMap的数据结构： 在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。 HashMap底层就是一个数组结构，数组中的每
Java：HashMap实现原理
OceanStar的博客
09-01 1811
哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中HashMap的实现原理进行讲解，并对JDK7的HashMap源码进行分析。 什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能 数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素.
Java集合 —— HashMap原理解析
m0_56602092的博客
04-28 4292
一、HashMap是什么 HashMap是一个存储key-value键值对的哈希表，表中每个元素的key都是唯一的（通过equals方法判断），查询时通过key的hashcode值即可定位到元素的存储地址，因此HashMap在理想情况下查询时间复杂度为O(1)。 1. 存储下标计算方法 HashMap底层通过Entry数组来存储元素，插入元素和查询元素时首先需要计算元素在数组中的存储下标，方法如下： 1. 通过key的hashCode()方法获取其hashcode值 2. 将这个hashcode值再通过h
Java HashMap 实现线程安全
程序员写的技术 FAQ 和杂文
11-15 1199
再 Java 1.5 版本引入 ConcurrentHashMap，实现线程安全。ConcurrentHashMap 将 hash 表分为 16 个桶（默认值），诸如 get,put,remove 等常用操作只锁当前需要用到的桶。试想，原来只能一个线程进入，现在却能同时 16 个写线程进入（写线程才需要锁定，而读线程几乎不受限制，并发性的提升是显而易见。ConcurrentHashMap是一个哈希表，支持检索的全并发和更新的高预期并发。
hashMap实现原理
热门推荐
yjclsx的博客
07-31 43万+
1. HashMap概述： 　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 2. HashMap的数据结构： 　　在java编程语言中，最基本的结构就是两种，一...
【Java 数据结构】模拟实现 HashMap
程序猿教你打篮球的博客
02-06 6672
本期主要讲解： 1、前言 2、成员变量的设定 3、构造方法 4、hash 方法以及 阈值判断方法 5、put 方法 6、resize 方法 7、get 方法
【Java】HashMap 实现原理
嗯哼的博客
09-10 5690
Java集合框架有两个顶级接口，一个是collection接口，另一个是map接口，hashmap便是map接口的重要实现类。首先看map接口。根据map键值对的特性，接口中必然有相关的方法，主要是：      前三个与map的操作有关，后三个与map遍历相关。   在map接口中，还定义了一个entry接口，hashmap实现本质上是一个entry的数组的链表。所以entry可以看成是h...
Java HashMap详解及实现原理
兴趣是最好的老师，勤能补拙
05-15 2107
Java HashMap是Java集合框架中最常用的实现Map接口的数据结构，它使用哈希表实现，允许null作为键和值，可以存储不同类型的键值对。HashMap提供了高效的存取方法，并且是非线程安全的。在Java中，HashMap被广泛应用于各种场景，如缓存、数据库连接池、路由器等。
【java】HashMap底层实现原理
酷酷的馫博客
12-26 1万+
【java】HashMap底层实现原理及面试题
深入解析java HashMap实现原理
09-03
Java中的HashMap是一个非常重要的数据结构，它实现了Map接口，提供了高效的数据存储和检索功能。HashMap的核心实现基于哈希表，其内部数据结构是数组与链表的结合，也就是所谓的“链表散列”结构。 1. **HashMap...
Java HashMap实现原理分析（一）
09-07
总的来说，Java HashMap的实现原理主要包括以下几个关键点： 1. 基于哈希表的数据结构，使用数组+链表的方式存储键值对。 2. 使用键的哈希值计算数组索引，通过异或和位移操作优化哈希分布。 3. 链地址法解决哈希...
Java8 HashMap的实现原理分析
09-02
Java8之后新增挺多新东西，接下来通过本文给大家介绍Java8 HashMap的实现原理分析，对java8 hashmap实现原理相关知识感兴趣的朋友一起学习吧
Java使用HashMap实现并查集
08-25
Java使用HashMap实现并查集 Java使用HashMap实现并查集是指使用Java语言中的HashMap数据结构来实现并查集。并查集是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以...
树状形式打印二叉树
Hooting的码农笔记本
04-12 1万+
树状结构打印二叉树，na
ajax发送get、post请求
Hooting的码农笔记本
04-15 1万+
ajax可以发送post或者get请求，并且keyi
字符输出大小不一致的问题
Hooting的码农笔记本
04-12 9849
在例如JTextArea这样的kongjian
Eclipse + Tomcat 配置
Hooting的码农笔记本
04-11 9598
开发环境 Eclipse For Java EE(Kepler Release) Tomcat(7.0) 开发步骤 点击Eclipse->Help->Install New Software.. 添加更新源：http://download.eclipse.org/callisto/releases/ 选中Web and J2EE Development并安装 新建
java hashmap底层实现
最新发布
10-17
Java中的HashMap是基于哈希表实现的，它通过哈希函数将键映射到存储桶中，然后在存储桶中查找值。具体来说，HashMap底层是由数组和链表（或红黑树）组成的。数组用于存储桶，链表（或红黑树）用于解决哈希冲突。 当...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值