HashMap源码实现

HashMap存储格式

首先来看看HashMap的数据存储格式：

从本质上来说，hashMap实际上是一个数组，数组的每个元素称为一个Node，这个Node实际上是一个链表，每个对象的hash值经过一些处理作为数组的key，hashMap通过key定位到数组对应的位置。当两个对象的hash值相同的时候，就会在链表的next元素进行拓展。

源码

本文主要要实现hashMap的put、get、扩容方法；
基本代码架构：

public class MyHashMap<K,V> {    //数组的初始大小    static final int DEFAULR_INITIAL_CAPACITY=16;    //安全因子    static final float DEFAULT_LOAD_FACTOR = 0.75f;    //扩容因子    static final int DEFAULT_DITATATION_FACROT=2;    private int size = 0;    //数组元素    private Node<K,V> table[] = null;    public V put(){        return null;    };    public V get(){        return null;    }    //Map的大小    public int size(){        return this.size;    }    //提供hash算法，确定Node在数组中的位置    private int indexOf(Object o){        return 0;    }    //扩容方法    private void dilatation() {     }    public class Node<K,V> implements Entry<K, V>{        @Override        public K getKey() {            return null;        }        @Override        public V getValue() {            return null;        }        @Override        public V setValue(V value) {            return null;        }    }}

关于构造

前面已经说过，数组的元素是由节点Node

private class Node<K,V> implements Entry<K, V>{        //Node在数组中的位置，根据对象的hash值确定        private int index;        private K key;        private V value;        //当hash值出现冲突以后，往链表中插入对象        private Node<K,V> next;        public Node(int index, K key, V value, Node<K, V> next) {            super();            this.index = index;            this.key = key;            this.value = value;            this.next = next;        }        @Override        public K getKey() {            return null;        }        @Override        public V getValue() {            return null;        }        @Override        public V setValue(V value) {            return null;        }    }

下面来看看HashMap的构造：

private Node<K,V> table[] = null;    //创建一个大小为默认值的数组    public MyHashMap() {        table = new Node[DEFAULR_INITIAL_CAPACITY];    }

hash算法indexOf方法实现:

//提供hash算法，确定Node在数组中的位置    public int indexOf(K  key){        //与数组length-1取模，确定返回值不大于数组的length-1        return hash(key) % (table.length-1);    }    //让hash值无符号右移16位，缩小hash值    static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

源码实现

put方法实现：

public V put(K key,V value){        //tab用来指向table，p当前数组位置的Node;        Node<K, V> tab[] = table;         Node<K,V> p;        int i = indexOf(key);        p = table[i];        if(p == null){            //如果数组的该位置没有元素            p = new Node<K, V>(i, key, value, null);            tab[i] = p;            return value;        }else{            //如果数组的该位置有元素            Node<K,V> e;//用于判断key是否相同,是否需要覆盖            if(p.index == indexOf(key)&&(p.key==key||key.equals(p.key))){                //key相同(这里我们可以看到map判断key是否相同需要他的hash值和equals都相同)                e = p;            }else{                //对p进行遍历                for(int count = 0 ; ; ++count){                    if((e=p.next)==null){                        //如果p链表没有后续元素                        p.next = new Node<K,V>(indexOf(key), key, value, null);                        break;                    }                    //如果链表中其他元素的key有相同的                    if(e.index==indexOf(key)&&(e.key==key||e.key.equals(key))){                        break;                    }                    //如果链表有后续元素，并且key和链表当前位置的元素key不用,将p指向p.next                    p= e;                }            }            //key有覆盖的情况出现,将key对应的value进行覆盖处理            if(e!=null){                e.value = value;                return value;            }            //e==null则没有覆盖情况            size++;            if(size>DEFAULR_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR){                //扩容;                dilatation();            }        }        return value;    };

get方法实现：

public V get(K key){        Node<K,V> tab[] ; Node<K,V> e ;        tab = table;        int index = indexOf(key);        e = tab[index];        //该key没有值        if(e == null){            return null;        }else{            //遍历Node e            do {                //获取e的值                if(key==e.key||key.equals(e.key)){                    return e.value;                }            } while ((e=e.next)!=null);        }        return null;    }

扩容方法dilatation

    //扩容方法    private void dilatation() {        Node<K, V> oldNode[] = table;        int oldCount = table.length;        //将容量扩张到两倍        int newCount = oldCount*DEFAULT_DITATATION_FACROT;        Node<K, V> newNode[] = new Node[newCount];        table = newNode;        for(int i = 0 ; i < oldCount ; i++){            if(oldNode[i]!=null){                Node<K,V> e = oldNode[i];                Node<K,V> tmp = oldNode[i];                //给newNode赋值,修改Node的index值                int newIndex = indexOf(tmp.getKey());                do {                    tmp.index = newIndex;                } while ((tmp=tmp.next)!=null);                newNode[newIndex] = e;            }        }    }