深入理解HashMap的存储原理

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,这个因子在时间代价和空间代价上达到了平衡.更高的负载因子可以降低表所需的空间,但是会增加查找代价.