java数据结构-简单的模仿实现HashMap类的部分函数

 HashMap的数据结构为 数组+单向链表。那么是如何添加数据以及扩容的时候数据如何重新散列的呢？我模仿者源码进行了简单的实现。

public class MyHashMap<K, V> {
    private int size;
    private static final int MINIMUM = 4;
    private static final int MAXMUM = 1 << 30;
    private int threshode;// 阈值
    // 用来强制扩容
    private static final Entry[] EMPTY_TABLE = new MyHashMapEntry[MINIMUM >> 1];
    MyHashMapEntry<K, V> entryForNullKey;// 存放空的键
    private MyHashMapEntry<K, V>[] table;// 核心

    public MyHashMap() {
        table = (MyHashMapEntry<K, V>[]) EMPTY_TABLE;
        threshode = -1;
    }

    public MyHashMap(int capacity) {
        if (capacity < 0) {
            throw new IllegalArgumentException("capacity:" + capacity);
        }
        if (capacity == 0) {
            table = (MyHashMapEntry<K, V>[]) EMPTY_TABLE;
            threshode = -1;
            return;
        }
        if (capacity < MINIMUM) {
            capacity = MINIMUM;
        } else if (capacity > MAXMUM) {
            capacity = MAXMUM;
        } else {
            capacity = roundUpToPowerOfTwo(capacity);
        }
        makeTable(capacity);
    }

    // put函数
    public V put(K key, V value) {
        if (key == null) {
            return putValueForNullKey(value);
        }
        int hash = secondHash(key.hashCode());
        MyHashMapEntry<K, V>[] tab = table;
        int index = hash & (tab.length - 1);// 找到需要存在数组的下表
        // 先检查是否存在相同的键
        for (MyHashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {

            if ((hash == e.hashcode) && (key.equals(e.key))) {
                V oldValue = e.getValue();
                e.setValue(value);
                return oldValue;
            }

        }
        // 如果超过阈值 来时进行扩容
        if (++size > threshode) {
            tab = doubleCapaticy();
            index = hash & (tab.length - 1);
        }
        addNewEntry(key, value, hash, index);

        return null;

    }

    // 返回size
    public int size() {
        return size;
    }

    // 获取值
    public V get(K key) {
        if (key == null) {
            MyHashMapEntry<K, V> entry = entryForNullKey;
            return entry == null ? null : entry.value;
        }
        MyHashMapEntry<K, V>[] entries = table;
        int hash = secondHash(key.hashCode());
        int index = hash & (entries.length - 1);
        for (MyHashMapEntry<K, V> n = entries[index]; n != null; n = n.next) {
            K eKey = n.key;
            if ((eKey == key) || ((n.hashcode == hash) && (key.equals(eKey)))) {
                return n.value;
            }
        }
        return null;
    }

    // 从链表头部插入
    private void addNewEntry(K key, V value, int hash, int index) {
        table[index] = new MyHashMapEntry<K, V>(key, value, hash, table[index]);
    }

    /**
     * @Description: 双倍扩容方法
     * @date 2017年9月23日 上午10:49:15
     */
    private MyHashMapEntry<K, V>[] doubleCapaticy() {
        MyHashMapEntry<K, V>[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXMUM) {
            return oldTable;
        }
        int newCapaticy = oldCapacity << 1;
        MyHashMapEntry<K, V>[] newTable = makeTable(newCapaticy);
        if (size == 0) {
            return newTable;
        }
        // 开始重新散列
        for (int j = 0; j < oldCapacity; j++) {
            MyHashMapEntry<K, V> e = oldTable[j];// 拿到每个羊肉串
            if (e == null) {
                continue;
            }
            int heighBit = e.hashcode & oldCapacity;
            MyHashMapEntry<K, V> broken = null;
            newTable[j | heighBit] = e;// 下标位置
            for (MyHashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
                int nextHeighBit = n.hashcode & oldCapacity;
                if (nextHeighBit != heighBit) {
                    if (broken == null) {
                        int newNextIndex = j | nextHeighBit;// 新的索引
                        newTable[newNextIndex] = n;
                    } else {
                        broken.next = n;
                    }
                    broken = e;
                    heighBit = nextHeighBit;
                }
            }
            if (broken != null) {
                broken.next = null;
            }
        }
        return newTable;
    }

    // 进行数组的散列 hashMap的hash算法
    private int secondHash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    // 放空key的
    private V putValueForNullKey(V value) {
        MyHashMapEntry<K, V> entry = entryForNullKey;
        if (entry == null) {
            entry = new MyHashMapEntry<K, V>(null, value, 0, null);
            size++;
            return null;
        } else {
            V oldValue = entry.getValue();
            entry.setValue(value);
            return oldValue;
        }
    }

    // 创建数组
    private MyHashMapEntry[] makeTable(int capacity) {
        // 创建局部变量以避免多线程访问该数组改变其长度时出现问题
        MyHashMapEntry[] newTable = new MyHashMapEntry[capacity];
        table = newTable;
        threshode = (capacity >> 1) + (capacity >> 2);
        return newTable;

    }

    // 转换成2的幂次方
    public static int roundUpToPowerOfTwo(int i) {
        i--;
        i |= i >>> 1;
        i |= i >>> 2;
        i |= i >>> 4;
        i |= i >>> 8;
        i |= i >>> 16;
        return i + 1;
    }

    // 初始化键值类
    static class MyHashMapEntry<K, V> implements Entry<K, V> {
        final K key;
        V value;
        final int hashcode;
        MyHashMapEntry next;

        public MyHashMapEntry(K key, V value, int hashCode, MyHashMapEntry next) {
            this.key = key;
            this.value = value;
            this.hashcode = hashCode;
            this.next = next;
        }

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

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

        @Override
        public V setValue(V value) {
            V oleValue = this.value;
            this.value = value;

            return oleValue;
        }

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

测试：

public static void main(String[] args) {
        MyHashMap<String, String> map = new MyHashMap<String, String>();
        map.put("dasdsa", "1");
        map.put("dasd12sa", "7");
        map.put("dasd4sa", "6");
        map.put("dasd542sa", "5");
        map.put("das56dsa", "4");
        map.put("dasd76sa", "3");
        map.put("dasd98sa", "2");
        map.put(null,"1");
        System.out.println(map.size());
        System.out.println("dasd98sa:"+map.get("dasd98sa"));
        map.put("dasd98sa", "000");
        System.out.println("dasd98sa:"+map.get("dasd98sa"));
        System.out.println(map.size());

    }

测试结果如下：
8
dasd98sa:2
dasd98sa:000
8