Java基础学习——HashMap原理学习

学习资料：

• Java编程思想 P492

忍不住吐槽，这书翻译的真是 。。。

---

1. SimpleHashMap 简易HashMap

/**
 * 一个简易版的HashMap 用来帮助理解原理
 * 
 * @author 英勇青铜5
 */
public class SimpleHashMap extends AbstractMap {
    private static final int SIZE = 2 << 3;
    @SuppressWarnings("unchecked")
    private LinkedList>[] buckets = new LinkedList[SIZE];//LinkedList数组
    
    /**
     * 用来存放 Key 和 Value
     *
     */
    public V put(K key, V value) {
        V oldValue = null;
        //根据Key的hashCode值来确定出一个index
        int index = Math.abs(key.hashCode()) % SIZE;
        //判断在数组角标为index的位置上，是否有LinkedList对象
        if (null == buckets[index]) {//没有
        //根据index来创建LinkedList对象，并把LinkedList对象放入数组
            buckets[index] = new LinkedList>();
        }
        //在数组角标为index的位置上有LinkedList对象  
        LinkedList> bucket = buckets[index];
        //初始化一个MapEntry对象
        MapEntry pair = new MapEntry(key, value);
        //标记 判断是否已经将键值对添加进SimpleHashMap中
        boolean found = false;
        //迭代器
        ListIterator> iterator = bucket.listIterator();
        //对LinkedList中的MapEntry进行遍历
        while (iterator.hasNext()) {
            MapEntry entry = iterator.next();
            //判断要存入的Key是否已经存在
            if (entry.getKey().equals(key)) {//存在
                oldValue = entry.getValue();//将旧的Value赋值给oldValue，方法最后返回用
                iterator.set(pair);//替换MapEntry
                found = true;//将标识设置为存在
                break;
            }
        }
        //遍历完 Key 不存在
        if (!found) {
            bucket.add(pair);//将MapEntry加入当前的LinkedList
        }
        return oldValue;
    }
    
    /**
     * 通过 Key 来取 Value
     *
     */
    public V get(Object key) {
        int index = Math.abs(key.hashCode()) % SIZE;
        if (null == buckets[index]) {
            return null;
        }
        for (MapEntry entry : buckets[index]) {
            if (entry.getKey().equals(key)) {
                return entry.getValue();
            }
        }
        return null;
    }
    
    /**
     * AbstractMap必须实现的抽象方法
     * 将Map.Entry对象存入Set集合
     */
    @Override
    public Set> entrySet() {
        Set> set = new HashSet<>();
        //对LinkedList数组进行遍历
        for (LinkedList> bucket : buckets) {
            if (null == bucket) {
                continue;
            }
            for (MapEntry entry : bucket) {
                set.add(entry);
            }
        }
        return set;
    }
    
     /**
      * Map.Entry接口实现
      * 用来保存和读取 Key，Value
      */
    static class MapEntry implements Map.Entry {
        private K key;
        private V value;

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

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

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

        @Override
        public V setValue(V v) {
            V result = this.value;
            this.value = v;
            return result;
        }
        /**
         * 得到HashCode值
         * 将Key的hashCode值Value的hashCode值进行异或运算 
         * 
         */
        @Override
        public int hashCode() {
            return (null == key) ? 0 : key.hashCode() ^ ((null == value) ? 0 : value.hashCode());
        }
        /**
         * 通过Key和Value来比较放入对象是否相同
         */
        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof MapEntry))//不是MapEntry
                return false;
            @SuppressWarnings("rawtypes")
            MapEntry me = (MapEntry) obj;
            return null == key ? null == me.getKey(): key.equals(me.getKey()) 
                    && 
                   (null == value ? null == me.getValue() : value.equals(me.getValue()));
        }
        
        public String toString(){
            return key + "==" +value;
        }
    }
}

private static final int SIZE = 2 << 3，这里SIZE大小其实无所谓，但由于后面有int index = Math.abs(key.hashCode()) % SIZE，SIZE为2的n次方比较好

private LinkedList>[] buckets = new LinkedList[SIZE]

这个LinkedList数组相当关键

查询一个Value的速度受限于对Key进行遍历一 一比较的速度，Hash表可以将Key存在某个地方，能够快速定位

存储一组元素最快的数据结构是数组。但数组一旦确定后，大小是固定的，不能修改，并且不同的Key可能会产生相同的下表造成冲突。而SimpleHashMap中想要保存的键值对数量是不确定的，通常使用外部链接来解决冲突，将同一Hash值得Key都存入同一个LinkedList中

LinkedList数组内有2 << 3 = 16个LinkedList

利用key.hashCode()得到的值，进行% SIZE运算可以保证index肯定小于SZIE,这样MapEntry肯定能够找到一个LinkedList来进行保存

同样根据Key的hashCode值计算得到的index来进行查询时，通过buckets[index]获取到Key所在的LinkedList，只需对这个确定的LinkedList进行便利，而不用遍历所有的LinkedList中的全部MapEntry的key都一 一比较，这样会比较高效

---

测试：

public class SimpleMapTest {
    public static void main(String[] args) {
        SimpleHashMap s = new SimpleHashMap<>();
        for (int i = 0; i < 5; i++) {
            s.put(i, "这是" + i);
        }
        //打印Map
        System.out.println(s);
        //打印key为2 的value
        System.out.println(s.get(2));
        //打印Map.Entry
        System.out.println(s.entrySet());
    }
}

运行结果：

运行结果

---

2.最后

在JDK 1.8，HashMap内部采用位桶+链表+红黑树，当链表长度超过阈值（8）时，将链表转换为红黑树，深入学习可以看美团点评技术团队的Java 8系列之重新认识HashMap，写的非常好。不过，看了看，都啥鬼跟啥鬼，暂时丢一边，得先把数据结构补一补

本人很菜，有错误请指出

共勉 ： ）