【Java】HashMap源码剖析：真假HashMap

最新推荐文章于 2021-02-26 08:22:06 发布
最新推荐文章于 2021-02-26 08:22:06 发布
阅读量229 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zfpigpig/article/details/106479085
版权

刚入门ACM的时候，经常会处理字符串相关问题。下面有一道很常规的题：

计算一个小写英文字符串中每个字符出现的频率。

 如果不了解ASCII，用Java直接实现：

public class TestMap {
  public static void main(String[] args) {
    String input = "abcdefade";
    Map<Character, Integer> charMap = new HashMap<Character, Integer>();
    for (int i = 0; i < input.length(); i++) {
      char c = input.charAt(i);
      Integer count = charMap.get(c);
      count = count==null?1:count+1;
      charMap.put(c, count);
    }
    for (Entry<Character, Integer> entry : charMap.entrySet()) {
      System.out.println(entry.getKey() + ":" + entry.getValue());
    }
  }
}

但是熟悉ACM，一般都会写成如下：

public class TestMap2 {
  public static void main(String[] args) {
    String input = "abcdefade";
    int[] counts = new int[26];
    for (int i = 0; i < input.length(); i++) {
      char c = input.charAt(i);
      counts[c-97]++;
    }
    for (int i = 0; i < counts.length; i++) {
      if(counts[i] != 0) {
        System.out.println((char)(i+97) + ":" +  counts[i]);
      }
    }
  }
}

稍微变化一下，我们就得到了假的HashMap。

public class TestMap2 {
  public static void main(String[] args) {
    String input = "abcdefade";
    PseudoMap charMap = new PseudoMap();
    for (int i = 0; i < input.length(); i++) {
      char c = input.charAt(i);
      Integer count = charMap.get(c);
      count = count==0?1:count+1;
      charMap.put(c, count);
    }
    charMap.print();
  }
  
  private static class PseudoMap {
    private int[] counts = new int[26];
    
    public void put(char c, int count) {
      counts[c-97] = count;
    }
    
    public int get(char c) {
      return counts[c-97];
    }
    
    public void print() {
      for (int i = 0; i < counts.length; i++) {
        if(counts[i] != 0) {
          System.out.println((char)(i+97) + ":" +  counts[i]);
        }
      }
    }
  }
}

 对比一下我们不难发现，map的本质就是以key为下标数组，是运用了计算机中空间换时间这种常用思想。不过上述的假map中有一个显而易见的问题，就是key值必须是char类型，如何扩展到所有类型是一个必须要解决的问题。这时候就要轮到hash算法登场了。Java中的hash算法一般都是根据对象的情况来算出int型的hashcode，例如Integer就是本身，String是s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]等，这时候我们通过hashcode作为下标就能解决只能是char类型的限制。代码如下：

public class TestMap3 {
  public static void main(String[] args) {
    String input = "abcdefade";
    PseudoMap<Character, Integer> charMap = new PseudoMap<Character, Integer>();
    for (int i = 0; i < input.length(); i++) {
      char c = input.charAt(i);
      Integer count = charMap.get(c);
      count = count==null?1:count+1;
      charMap.put(c, count);
    }
    charMap.print();
  }
  
  private static class PseudoMap<K, V> {
    private Node<K, V>[] table = (Node<K,V>[])new Node[1000];
    
    public void put(K key, V value) {
      table[key.hashCode()] = new Node(key, value);
    }
    
    public V get(K key) {
      Node<K, V> node = table[key.hashCode()];
      return node==null?null:node.getValue();
    }
    
    public void print() {
      for (int i = 0; i < table.length; i++) {
        if(table[i] != null) {
          System.out.println(table[i]);
        }
      }
    }
    
    private static class Node<K, V> {
      K key;
      V value;
      
      public Node(K key, V value) {
        this.key = key;
        this.value = value;
      }

      public V getValue() {
        return value;
      }
      
      @Override
      public String toString() {
        return key + ":" + value;
      }
    }
  }
}

但是这时候又会带了新的问题：hashcode是int，int值很大，不可能直接就创建一个int上限的数组。如何让一个int变成一定范围内的数值，我们不妨把问题变成如何把问题变成如何让一个int变成10以内的正整数（0-9），显而易见用取余mod。变换一下代码如下：

 private static class PseudoMap<K, V> {
    private int len = 10;    
    public void put(K key, V value) {
      int i = key.hashCode() % len;
      table[i] = new Node(key, value);
    }
    
    public V get(K key) {
      int i = key.hashCode() % len;
      Node<K, V> node = table[i];
      return node==null?null:node.getValue();
    }
}

10进制一般用于数学计算，2进制一般用于计算机，所以我们不妨取len为2^n。如果len = 8，8的二进制是1000，任何一个int数m能表示成二进制bb...bbaaa(b,a都是0，1)，即m=8*(bb...bb)+aaa，对8取余就是aaa，所以如果len是2^n，余数就是m二进制取后n-1，所以modM=m%len=m&(len-1)，变换一下代码如下：

private static class PseudoMap<K, V> {
    private int len = 1 << 4;
    private Node<K, V>[] table = (Node<K,V>[])new Node[len];
    
    public void put(K key, V value) {
      table[getIndex(key.hashCode())] = new Node(key, value);
    }
    
    public V get(K key) {
      Node<K, V> node = table[getIndex(key.hashCode())];
      return node==null?null:node.getValue();
    }
    
    private int getIndex(int hashCode) {
      return hashCode & (len-1);
    }
}

借助取余的思想能解决数组上限的问题，但是会加剧冲突hash冲突，例如1和17，对于16取余都是1，解决这个问题可以在每个table的位置上放多个元素。这边我们用链表来实现：

private static class PseudoMap<K, V> {
    private int len = 1 << 4;
    private Node<K, V>[] table = (Node<K,V>[])new Node[len];
    
    public void put(K key, V value) {
      int index = getIndex(key.hashCode());
      Node<K, V> node = table[index];
      if(node == null) {
        table[index] = new Node(key, value, null);
      } else {
        Node<K, V> tempNode = node;
        while(true) {
          if(tempNode.getKey().equals(key)) {
            tempNode.setValue(value);
            break;
          }
          if(tempNode.getNext() == null) {
            table[index] = new Node(key, value, node);
            break;
          } else {
            tempNode = tempNode.getNext();
          }
        }
      }
    }
    
    public V get(K key) {
      V v = null;
      Node<K, V> node = table[getIndex(key.hashCode())];
      if(node != null) {
        while(true) {
          if(node.getKey().equals(key)) {
            v = node.getValue();
            break;
          }
          if(node.getNext() == null) {
            break;
          } else {
            node = node.getNext();
          }
        }
      }
      return v;
    }
    
    private int getIndex(int hashCode) {
      return hashCode & (len-1);
    }
    
    public void print() {
      for (int i = 0; i < table.length; i++) {
        if(table[i] != null) {
          System.out.println(table[i]);
        }
      }
    }
    
    private static class Node<K, V> {
      K key;
      V value;
      Node<K, V> next;
      
      public Node(K key, V value, Node<K, V> next) {
        this.key = key;
        this.value = value;
        this.next = next;
      }
      
      public K getKey() {
        return key;
      }

      public V getValue() {
        return value;
      }
      
      public void setValue(V value) {
        this.value = value;
      }

      public Node<K, V> getNext() {
        return next;
      }

      @Override
      public String toString() {
        return key + ":" + value;
      }
    }
  }

如果len是固定大小，随着数据量的增涨，必然会导致链表过长。链表的查询效率是O(n)，多链表或者链表过长，都会影响查询效率。解决这个问题就是尽量让node均匀分布在table中，所以要按需扩容。简单实现我们可以当数据个数==len选择扩容。代码如下：

 private static class PseudoMap<K, V> {
    private int len = 1 << 4;
    private Node<K, V>[] table = (Node<K,V>[])new Node[len];
    private int size = 0;
    
    public void put(K key, V value) {
      int hash = key.hashCode();
      int index = getIndex(hash);
      Node<K, V> node = table[index];
      if(node == null) {
        table[index] = new Node<K,V>(hash,key, value, null);
      } else {
        Node<K, V> tempNode = node;
        while(true) {
          if(tempNode.getKey().equals(key)) {
            tempNode.setValue(value);
            break;
          }
          if(tempNode.getNext() == null) {
            table[index] = new Node<K,V>(hash, key, value, node);
            break;
          } else {
            tempNode = tempNode.getNext();
          }
        }
      }
      size++;
      if(size >= len) {
        resize();
      }
    }
    
    private void resize() {
      int oldLen = len;
      len = len << 1;
      Node<K, V>[] newTable = (Node<K,V>[])new Node[len];
      //copy table => newTable
      for (int i = 0; i < oldLen; i++) {
        Node<K,V> node = table[i];
        if(node == null) {
          continue;
        }
        // if i=1
        // when len=16, key is 1 17 33 65
        // when len=32, 1 33 -> index 1, 17 65 -> index 17(1+len)
        while(true) {
          int index = (node.hash&oldLen)==0?i:i+oldLen;
          newTable[index] = new Node<K, V>(node.getHash(), node.getKey(), node.getValue(), newTable[index]);
          if(node.getNext() != null) {
            node = node.getNext();
          } else {
            break;
          }
        }
      }
      table = newTable;
    }
    
    public V get(K key) {
      V v = null;
      Node<K, V> node = table[getIndex(key.hashCode())];
      if(node != null) {
        while(true) {
          if(node.getKey().equals(key)) {
            v = node.getValue();
            break;
          }
          if(node.getNext() == null) {
            break;
          } else {
            node = node.getNext();
          }
        }
      }
      return v;
    }
    
    private int getIndex(int hashCode) {
      return hashCode & (len-1);
    }
    
    public void print() {
      for (int i = 0; i < table.length; i++) {
        if(table[i] != null) {
          System.out.println(table[i]);
        }
      }
    }
    
    private static class Node<K, V> {
      int hash;
      K key;
      V value;
      Node<K, V> next;
      
      public Node(int hash, K key, V value, Node<K, V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
      }
      
      public int getHash() {
        return hash;
      }

      public K getKey() {
        return key;
      }

      public V getValue() {
        return value;
      }
      
      public void setValue(V value) {
        this.value = value;
      }

      public Node<K, V> getNext() {
        return next;
      }

      @Override
      public String toString() {
        return key + ":" + value;
      }
    }
  }

到此我们的假hashMap就基本完成了，但是其实它还有很多细节没有完善，如果有感兴趣的，可以去看一下HashMap的源码，一定会有更多的理解。 代码只是本人一点拙见，如有任何问题，望斧正。

 

 

 

 

zfpigpig
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中Map详解
Zhujiang
03-05 3万+
用法 Map:java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的两种常用的遍历方式。 map存放值的时候通过put存放，如果key值相等的话会把之前存放的值覆盖。 ...
hashMap伪代码
小黄宝宝的专栏
01-22 4165
hashMap原理的伪代码 V put(K k , V v) { int hashCode = hashCode(k); Node node = new Node(k, v); if (table[hashCode] == null) { table[hashCode] = node; } else { Node firstNode = table[hashC...
漫画：什么是HashMap？
阿里云开发者
04-20 2541
简介：众所周知，HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。那你知道HashMap默认的初识长度是多少？为什么这么规定？高并发情况下，为什么HashMap可能会出现死锁？在Java8当中，HashMap的结构有什么样的优化？本文将为你深度解读HashMap的灵魂三问！...
【case】并发环境下HashMap引起full gc排查
lichunan的专栏
04-13 865
现象 最近上线一个需求，完成需求的过程对代码进行了一次重构。应用发布后半个小时左右，发现一个机器报警，load过高。登陆机器看CPU使用情况，发现load已经正常，看下CPU使用情况，发现有一个核跑满，其他CPU使用率很低。大概一个小时后，其他机器陆续报警，发现同样的问题，紧急回滚应用。 应用运行在16G内存的虚机上，整个JVM11G内存，其中新生代3G，CMS gc，JDK7。 第一反应是
HashMap的两种取出方式
那杯热咖啡
08-15 480
学习笔记记录：直接上代码 import java.util.*; import java.util.Map.Entry; class Student implements Comparable<Student>{ private String name; private int age; Student(String name,int age){ ...
java juc 自旋锁_玩转Java并发工具，精通JUC，成为并发多面手
weixin_36263314的博客
02-26 676
课程介绍:在处理Java并发问题时，需要使用各种工具。但市面上缺少对并发工具成体系的讲解。本课程深度解密JUC库，对Java并发常见的工具类进行从使用到原理的详解，包括CAS+AQS+ThreadLocal+ConcurrentHashMap+线程池+各种锁+并发综合实战项目等。在掌握工具的同时，建立起整个并发工具类的知识体系，并上手一个高性能缓存的实战项目。课程对于面试和实际工作都非常有帮助，还...
Java就业面试问题大全
slny1921394421的博客
07-19 2988
Java就业面试问题汇总
Java集合框架源码剖析：HashSet 和 HashMap
12-22
　之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 　HashMap实现了Map...
java7hashmap源码-java:Java
06-04
hashmap源码 Table Of Contents day01_JAVA语言概述与基本语法：标识符、变量也变量分类、源码_反码_补码、进制转换、编码与字符集 day02_基本语法.运算符：算术运算符、赋值运算符、比较运算符、逻辑运算符、位...
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
HashMap源码剖析共10页.pdf.zip
最新发布
11-21
《HashMap源码剖析》 HashMap是Java编程语言中一个非常重要的数据结构，它在实际开发中被广泛应用。作为集合框架的一部分，HashMap实现了Map接口，提供了高效、非同步的键值对存储功能。在这个10页的PDF文档中，...
【Java】java连接ldap
热门推荐
行路中
03-13 1万+
首先必须了解ldap，ldap相关可以问度娘。这边我重点要提的是dn(distinguished name)，通俗的来说就是唯一标示。     然后现在可以先下一个ldapadmin，通过ldapadmin先连接已经配置好的ldap，下面是微软ad的图。 比如administrator这个用户的dn就是cn=administrator,cn=users,dc=ds-66,dc=com(
【JAVA】unicode为12288字符
行路中
11-15 1万+
今天做一个导入数据功能时发现一个问题，就是一个unicode为12288的字符显示为空格，但是用java trim()函数无法去除。测试代码如下 public class TstSeven { public static void main(String[] args) { String str = " "; printStrAscii(str); char space = 122
【Java】浅析Collections.unmodifiableList
行路中
05-29 4982
类中成员和方法的可见性一直是JAVA程序员必须时刻关注的问题。常量我们通常都会使用final去修饰，在给final常量赋值的时候，IDE会有很明显的报错。但是我们对于常量数组（集合）一般也会这样，例如public static final String[] STR_LIST = {"a", "b"}，我们一般都会认为这种写法没有太大的问题，但是如果运行如下代码： public class TestList { public static final String[] STR_LIST = {"a",
【Java】java获取exe文件版本(跨系统版本)
行路中
10-18 3469
exe文件版本一般用于版本管理和客户版本更新，对exe右键->属性，选择版本就能看见。如下图   如果需要再windows上使用java读取exe文件版本，推荐使用jna.jar。本jar包可以调用本地c/c++类库，非常方便就能获取到exe文件版本。但如果是在其他系统上，那就没法用了，因为本地根本就没有此类库。   跨系统读取exe文件版本其实想法很简单，版本号就在文件里，去读文件不就行
【JAVA】AES算法的java实现
行路中
01-30 2859
java其实本身自带了Aes的实现。这里程序只是作为交流吧。有问题多多指正。 public class AES { public static final byte[] sBox= { (byte)0x63,(byte)0x7c,(byte)0x77,(byte)0x7b,(byte)0xf2,(byte)0x6b,(byte)0x6f,(byte)0xc5, (byte)0x30,(
【Java】定时任务的几种实现方式
行路中
06-05 2631
第一种的是最简单的，我在写demo和测试的时候经常用，原理就是通过while来无限循环和sleep来控制时间间隔。 public class TimeTask2 { public static void main(String[] args) { boolean status = true; while(status) { Calendar cal = Calendar.ge
【Java】Java的AES的算法实现（增加解密算法，优化域算法）
行路中
11-22 1864
前面已经介绍了phpAES优化和解密，现在介绍一下java的AES优化和解密算法。 AES.java public class Aes { public static final byte[] sBox = { (byte)0x63,(byte)0x7c,(byte)0x77,(byte)0x7b,(byte)0xf2,(byte)0x6b,(byte)0x6f,(byte)0xc5,
Java HashMap底层详解：高效存储与并发机制
4. 容量管理：HashMap有初始容量限制，当元素数量达到一定阈值（负载因子）时，会自动扩容，通过增加数组大小并重新哈希键值对，以维持良好的性能。 此外，报告还讨论了HashMap的线程安全机制，虽然基本版本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zfpigpig

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值