深入理解HashMap的存储原理

最新推荐文章于 2020-12-20 04:50:10 发布
最新推荐文章于 2020-12-20 04:50:10 发布
阅读量417 收藏 1
点赞数 1
分类专栏： java 文章标签： HashMap equals 性能分析 存储原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianmlin1/article/details/78937400
版权

HashMap是使用频率比较高的集合容器。本文将通过一个简单的案例来挖掘HashMap的存储原理。不足之处，还请谅解!

代码案例

  • 模拟Entry
package com.tml.collection.map;

import java.util.Map;

/**
 * <p>模拟map的键值对entry
 * @author Administrator
 *
 */
public class MapEntry<K,V> implements Map.Entry<K, V> {
    private K key;
    private V value;

    public MapEntry(K key,V value){
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return this.key;
    }

    @Override
    public V getValue() {
        return this.value;
    }

    @Override
    public V setValue(V value) {
        V result = this.value;
        this.value = value;
        //返回之前的value
        return result;
    }

    @Override
    public int hashCode() {
        return (this.key == null ? 0 : key.hashCode())^
                (this.value == null ? 0 : value.hashCode());
    }

    @SuppressWarnings("rawtypes")
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof MapEntry)){
            return false;
        }

        MapEntry  entry = (MapEntry) obj;
        return (this.key == null ? entry.getKey() == null :this.key.equals(entry.getKey()))&&
                (this.value == null ? entry.getValue() == null :this.value.equals(entry.getValue()));
    }

    @Override
    public String toString() {

        return this.key+"="+this.value;
    }

}
  • 模拟HashMap的实现
package com.tml.collection.map;

import java.util.AbstractMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

/**
 * <p>HashMap的简单实现
 * @author Administrator
 *
 */
public class SimpleHashMap<K,V>  extends AbstractMap<K, V>{
    //桶位的长度
    private static final int SIZE = 997;

    @SuppressWarnings("unchecked")
    LinkedList<MapEntry<K, V>>[] buckets = new LinkedList[SIZE];


    public static void main(String[] args) {
        SimpleHashMap<String, String> map = new SimpleHashMap<String,String>();
        map.put("123", "qaz");
        map.put("234", "wsx");
        System.out.println(map);
        System.out.println(map.get("123"));
        System.out.println(map.entrySet());
    }

    public V put(K key,V value){
        V oldValue =  null;
        int index=Math.abs(key.hashCode()) % SIZE;
        if(buckets[index] == null){
            buckets[index] = new LinkedList<MapEntry<K, V>>();
        }
        LinkedList<MapEntry<K, V>> bucket = buckets[index];
        MapEntry<K, V> pair = new MapEntry<K, V>(key, value);
        boolean found = false;
        ListIterator<MapEntry<K, V>> iterator = bucket.listIterator();
        while(iterator.hasNext()){
            MapEntry<K, V> ipair = iterator.next();
            if(ipair.getKey().equals(key)){
                oldValue = ipair.getValue();
                iterator.set(ipair);
                found = true;
                break;
            }
        }

        if(!found){
            buckets[index].add(pair);
        }
        return oldValue;
    }


    public V get(Object key){
        int index = Math.abs(key.hashCode()) % SIZE;
        if(buckets[index] == null){
            return null;
        }
        for(MapEntry<K, V> ipair : buckets[index]){
            if(ipair.getKey().equals(key)){
                return ipair.getValue();
            }
        }
        return null;

    }

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> set = new HashSet<Map.Entry<K,V>>();
        for(LinkedList<MapEntry<K, V>> bucket :buckets){
            if(bucket == null){
                continue;
            }
            for(MapEntry<K, V> mpair : bucket){
                set.add(mpair);
            }
        }
        return set;
    }

}
  • 自定义对象
package com.tml.collection.map;

public class Person {
    private String id;
    private int age;
    private String addres;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getAddres() {
        return addres;
    }
    public void setAddres(String addres) {
        this.addres = addres;
    }


    public Person(String id) {
        super();
        this.id = id;
    }
/*
 * hashcode和equals都是根据id来作为基准的
 * @see java.lang.Object#hashCode()
 */
//  @Override
//  public int hashCode() {
//      final int prime = 31;
//      int result = 1;
//      result = prime * result + ((id == null) ? 0 : id.hashCode());
//      return result;
//  }


    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }
}
  • equals()/hashCode()方法测试说明
package com.tml.collection.map;

import java.util.Map;

public class EqualsDemo {
    public static void main(String[] args) {
        Person person=new Person("123");
        Map<Person, Integer> map = new SimpleHashMap<Person, Integer>();
        map.put(person, 12);

        System.out.println(map.get(new Person("123")));//应该得到的是12,但是实际得到的是null
    }

}

总结说明

  • 存储一组元素最快的数据结构是数组,所以使用数组来存储key的信息.通过key对象生成一个数字作为数组的下标,该下标就是散列码.数组并不直接保存entry,而是保存一个list,因为不同的key可能产生相同的散列码;
  • 根据下标找到数组中对应的list,对list中的值使用equals()方法线性查询.因为不是对整个数组进行线性查询,这便是HashMap查询效率比较高的原因;
  • HashMap存放元素是根据key值的equals()方法来判断的,实际开发中经常用String作为key,是因为String重写了equals()方法.若想用自己定义的Bean来作为key,必须重写该对象的equals()方法和hashCode()方法;
  • 上面的案例Person类中,根据id来判断同一个对象重写了equals()方法,但是没有重写hashCode()方法.导致获取不到对象.根本原因就是:put的时候hashCode()方法产生的值和get的时候产生的hashCode()的值是不一样的.故而存放和取出的数组下标不一样.所以重写equals()方法必须重写hashCode()方法,并且判断的条件也必须一致,比如Person类中判断同一个Person是根据id;
  • 根据key值生成散列码,根据散列码找到数组的下标.但是若一个HashMap中的key值产生的散列码比较集中,那么HashMap会在某些区域负载比较重,查询的效率就会随着集合中元素的增加和显著下降.因此,要求散列码分布均匀.散列码的生成是根据hashCode()方法,所以有效重写hasCode()方法至关重要;
  • 数组中的元素称为桶位,为使散列分布均匀,桶的数量通常使用质数.但是对于现代处理器来说,除法求余数是最慢的操作.使用2的整数次方长度的散列表,可以用掩码代替除法,可以降低%运算的开销;
  • 数组的长度表示容量,数组中存储了多少元素表示尺寸,而尺寸/容量表示负载因子.HashMap使用默认的负载因子是0.75,这个因子在时间代价和空间代价上达到了平衡.更高的负载因子可以降低表所需的空间,但是会增加查找代价.
林犀居士
关注
专栏目录
HashMap存储原理分析
qq_45337431的博客
08-22 270
如果要了解HashMap的底层存储原理，首先要知道几个算法，也是HashMap存储的核心算法。 Hash表容量计算方法 HashMap底层维护的就是哈希表，其容量计算方法核心源码如下： static final int tableSizeFor(int cap) { int n = cap - 1;//n0 n |= n >>> 1; //n1 n |= n >&gt...
HashMap的存储原理
weixin_30593261的博客
07-14 120
HashMap是java中相当重要的数据结构，使用HashMap的场景非常之多，因此，了解HashMap实现的过程和原理，是非常有必要的，在一些面试中也会经常被问到。好了，我们赶紧来研究java内部是怎么实现HashMap的吧！ 首先，我们都知道，数组的元素查找的效率是不错的，但是涉及到插入操作和删除操作，效率低下，因为可能会涉及到后续元素位置的迁移。而另外一个数据结构链表则很...
HashMap存储原理
qixiang_chen的博客
04-14 3554
HashMap存储的数据存放在内存中，提高HashMap数据寻址速度是重点要解决的问题，所以HashMap底层的存储结构非常关键，如果使用数组存储，时间复杂度为Ｏ(1)，使用链表存储，时间复杂度为O(n)，如果使用二叉树存储，时间复杂度为O(lg(n))。所以HashMap优先使用数组存储，如果出现hash碰撞，采用链表存储，如果链表长度大于8，寻址速度明显下降，进一步采用红黑树存储，将寻址效率提...
HashMap的存储结构及原理
weixin_34406796的博客
03-08 1040
1、HashMap的数据结构(HashMap通过hashcode对其内容进行高速查找，是无序的)   数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。   数组 ：数组的存储区是连续的，占用内存严重，故空间复杂度非常大。但数组的二分查找时间度小；数组的特点：寻址easy，插入和 删除困难。   链表 ：链表的储存区离散。占用内存比較宽松。故空间复杂度非常...
HashMap的原理
qq_42478956的博客
03-01 158
HashMap的数据结构 数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。 数组 数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难； 链表 链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。 哈希表 那么我们能不能综...
HashMap原理的深入理解
08-26
HashMap原理的深入理解 HashMap是基于哈希表的Map接口的非同步实现，提供了所有可选的映射操作，并允许使用null值和null键。HashMap储存的是键值对，HashMap很快。此类不保证映射的顺序，特别是它不保证该顺序恒久...
深入解析java HashMap实现原理
09-03
综上所述，理解HashMap的实现原理对于优化Java程序性能至关重要，尤其是在处理大量数据或并发场景时。在实际应用中，应根据具体需求选择合适的数据结构，例如，如果需要线程安全，可以选择ConcurrentHashMap；如果对...
hashmap实现原理
10-15
在深入探讨HashMap的实现原理之前，我们需要了解两个关键的接口方法：`hashCode()`和`equals()`。 根据《Effective JAVA》的建议，当重写`equals()`方法时，也应重写`hashCode()`方法。这是因为在HashMap中，`...
java中HashMap的原理分析
09-02
在深入探讨HashMap的原理之前，我们先来澄清几个基本概念。 1. **哈希码（Hash Code）**：HashMap依赖于对象的哈希码来进行快速查找。哈希码是一个整数值，由对象的`hashCode()`方法计算得出。理想的哈希码应尽可能...
java面试题-HashMap原理
lxf310的专栏
10-31 931
转载自：http://blog.chinaunix.net/uid-11775320-id-3143919.html 1.    HashMap概述    HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。   2.    HashMap的数据结构    在java编
hashmap储存有向图_HashMap的存储原理
weixin_39785600的博客
12-20 208
HashMap是java中相当重要的数据结构，使用HashMap的场景非常之多，因此，了解HashMap实现的过程和原理，是非常有必要的，在一些面试中也会经常被问到。好了，我们赶紧来研究java内部是怎么实现HashMap的吧！首先，我们都知道，数组的元素查找的效率是不错的，但是涉及到插入操作和删除操作，效率低下，因为可能会涉及到后续元素位置的迁移。而另外一个数据结构链表则很好的解决了这个问题，插...
HashMap,LinkedHashMap,TreeMap的数据存储原理
jin6872115的博客
12-31 374
HashMap的原理与HashSet的存储原理完全一致。请参考HashSet的数据存储原理 http://blog.csdn.net/jin6872115/article/details/78939484 LinkedHashMap的原理与HashSet的存储原理完全一致。请参考LinkedHashSet的数据存储原理 http://blog.csdn.net/jin6872115/ar
深入理解HashMap：原理与源码解析
"深入理解HashMap的实现原理" HashMap是Java中常用的一种数据结构，它提供了O(1)的平均时间复杂度来存储和检索元素。基于它的高效性能和灵活性，HashMap在许多场景下被广泛使用。在JDK 1.5版本中，HashMap的设计和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值