HashMap实现原理

Posted 2020-12-12 raorao1994

HashMap是数组+链表实现的，既然用到hash散列，那么肯定不可避免的会出现冲突问题，HashMap解决冲突的方法是拉链法，因为这里有用到数组，那么当容量不足的时候就需要进行扩容操作了，在HashMap中有个术语叫冲突，当冲突几率越来越高的时候就需要进行扩容操作了，那什么情况就叫冲突几率高呢？就是当我们的数组元素个数超过了数组原先大小*装填因子，默认情况下的装填因子是0.75，扩容有个坏处就是每次扩容之后都必须重新计算原先数组中的元素在新数组中的存储位置，这点比较消耗性能，所以一般情况下如果你已经能够确定最大需要多大散列范围的数组的话，建议还是能够指定大小；

接下来就是HashMap的put和set原理了： 

put操作：     

put操作和set操作进行操作的对象是主要是key，如果你查看源码的话会发现value只是跟着key的步伐在走而已，并没有实质性的进行操作，对于put操作，首先会计算出当前key对应的hash值，接着找到计算出来的hash值在数组中的下标位置，查看该下标位置处对应的链表是否为null，为空的话直接将当前键值对插入到该链表首位，不会执行当前key对象的equals方法；如果下标位置处对应的链表不为null的话，会通过for循环来通过key的equals方法来查看这个链表中有没有与当前键值相等的键值对Entry存在，有的话，会用当前值替换原先这个键值对的value值，遍历结束如果不存在的话，会将当前键值对插入到链表的头部，这个就是put过程了；

get操作：       

get操作过程思想可以借助于put过程，首先会计算出当前key值的hash值，接着找到此hash值在数组中的位置，找到这个位置对应的链表，接着通过for循环遍历这个链表，遍历过程中调用equals方法查看有没有等于当前key的键值对存在，有的话直接返回这个键值对对应的value值即可；       

HashMap注意点：  

HashMap是非线程安全的，也就是说你在使用迭代器的过程中有其他线程修改了map的话，你的程序可能会抛出ConcurrentModificationException异常，这就是我们常见的fail-fast机制了，原因在于我们在调用HashMap的迭代器里面的每个方法的时候，都会通过判断原先map被修改次数和当前被修改次数是否相等，不等的话直接就抛出了ConcurrentModificationException异常了，这点在ArrayList里面使用迭代器也会出现，具体解决方法就是使用ConcurrentHashMap代替HashMap了；
 HashMap是允许你的键或者值为null的；HashMap是不能保证随着时间的推移，你里面元素之间的顺序不变，原因就在于map中存放hash值的数组在扩容的时候会重新计算原先元素在新数组中位置的

简化实现MyHashMap：

/**
 * Created by rabbit on 14-5-4.
 */
public class MyHashMap {

    //默认初始化大小 16
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    //默认负载因子 0.75
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //临界值
    private int threshold;

    //元素个数
    private int size;

    //扩容次数
    private int resize;

    private HashEntry[] table;

    public MyHashMap() {
        table = new HashEntry[DEFAULT_INITIAL_CAPACITY];
        threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        size = 0;
    }

    private int index(Object key) {
        //根据key的hashcode和table长度取模计算key在table中的位置
        return key.hashCode() % table.length;
    }

    public void put(Object key, Object value) {
        //key为null时需要特殊处理，为简化实现忽略null值
        if (key == null) return;
        int index = index(key);

        //遍历index位置的entry，若找到重复key则更新对应entry的值，然后返回
        HashEntry entry = table[index];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                entry.setValue(value);
                return;
            }
            entry = entry.getNext();
        }
        //若index位置没有entry或者未找到重复的key，则将新key添加到table的index位置
        add(index, key, value);
    }

    private void add(int index, Object key, Object value) {
        //将新的entry放到table的index位置第一个，若原来有值则以链表形式存放
        HashEntry entry = new HashEntry(key, value, table[index]);
        table[index] = entry;
        //判断size是否达到临界值，若已达到则进行扩容，将table的capacicy翻倍
        if (size++ >= threshold) {
            resize(table.length * 2);
        }
    }

    private void resize(int capacity) {
        if (capacity <= table.length) return;

        HashEntry[] newTable = new HashEntry[capacity];
        //遍历原table，将每个entry都重新计算hash放入newTable中
        for (int i = 0; i < table.length; i++) {
            HashEntry old = table[i];
            while (old != null) {
                HashEntry next = old.getNext();
                int index = index(old.getKey());
                old.setNext(newTable[index]);
                newTable[index] = old;
                old = next;
            }
        }
        //用newTable替table
        table = newTable;
        //修改临界值
        threshold = (int) (table.length * DEFAULT_LOAD_FACTOR);
        resize++;
    }

    public Object get(Object key) {
        //这里简化处理，忽略null值
        if (key == null) return null;
        HashEntry entry = getEntry(key);
        return entry == null ? null : entry.getValue();
    }

    public HashEntry getEntry(Object key) {
        HashEntry entry = table[index(key)];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                return entry;
            }
            entry = entry.getNext();
        }
        return null;
    }

    public void remove(Object key) {
        if (key == null) return;
        int index = index(key);
        HashEntry pre = null;
        HashEntry entry = table[index];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                if (pre == null) table[index] = entry.getNext();
                else pre.setNext(entry.getNext());
                //如果成功找到并删除，修改size
                size--;
                return;
            }
            pre = entry;
            entry = entry.getNext();
        }
    }

    public boolean containsKey(Object key) {
        if (key == null) return false;
        return getEntry(key) != null;
    }

    public int size() {
        return this.size;
    }

    public void clear() {
        for (int i = 0; i < table.length; i++) {
            table[i] = null;
        }
        this.size = 0;
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("size:%s capacity:%s resize:%s

", size, table.length, resize));
        for (HashEntry entry : table) {
            while (entry != null) {
                sb.append(entry.getKey() + ":" + entry.getValue() + "
");
                entry = entry.getNext();
            }
        }
        return sb.toString();
    }
}

class HashEntry {
    private final Object key;
    private Object value;
    private HashEntry next;

    public HashEntry(Object key, Object value, HashEntry next) {
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public Object getKey() {
        return key;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public HashEntry getNext() {
        return next;
    }

    public void setNext(HashEntry next) {
        this.next = next;
    }
}