链地址法手写HashMap

闲暇之余，复习一下HashMap，简单手写一个HashMap

JDK 1.7 : 数组+链表 

JDK 1.8：数组+ （链表|红黑树）

本文简单实现一个数据+链表的HashMap，具体结构如下

废话不多说，上代码

​
import org.apache.commons.lang3.StringUtils;


public class NewHashMap<K, V> {

    private Integer DEFAULT_SIZE = 16;

    private float loadFactor = 0.75f;

    private int size;

    Node<K, V>[] buckets;

    class Node<K, V> {
        private K key;
        private V value;
        private Node<K, V> next;

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

        /**
         * 链表连接
         */
        public Node(K key, V value, Node<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        @Override
        public String toString() {
            return key + "=" + value;
        }
    }

    public NewHashMap() {
        buckets = new Node[DEFAULT_SIZE];
        this.size = 0;
    }

    public NewHashMap(int size) {
        buckets = new Node[size];
        this.size = 0;
    }

    /**
     * 获取桶位置：hashCode()+取余
     */
    public int getIndex(K key, int bucketLength) {
        int hashCode = key.hashCode();
        int index = hashCode % bucketLength;
        return Math.abs(index);
    }

    public void put(K key, V value) {
        if (size >= loadFactor * buckets.length) {
            resize();
        }
        putNode(key, value, buckets);
    }

    /**
     * 链表法插入值
     */
    private void putNode(K key, V value, Node<K, V>[] table) {
        int index = getIndex(key, table.length);
        Node node = table[index];
        // 插入位置为空
        if (node == null) {
            table[index] = new Node<>(key, value);
            size++;
        }

        // 插入位置不为空，说明发生冲突，使用链地址法，遍历链表
        while (node != null) {
            // key相同，覆盖
            if (node.key.hashCode() == key.hashCode() && (node.key == key || node.key.equals(key))) {
                node.value = value;
                return;
            }
            node = node.next;
        }
        // 当前key不在链表中的话，插入到链表头部
        Node newNode = new Node(key, value, table[index]);
        table[index] = newNode;
        size++;
    }

    /**
     * 扩容
     */
    private void resize() {
        Node<K, V>[] newBuckets = new Node[buckets.length * 2];
        rehash(newBuckets);
        buckets = newBuckets;
    }

    /**
     * 新桶进行散列
     */
    private void rehash(Node<K, V>[] newBuckets) {
        size = 0;
        for (int i = 0; i < size; i++) {
            if (buckets[i] == null) {
                continue;
            }
            Node<K, V> bucket = buckets[i];
            while (bucket != null) {
                putNode(bucket.key, bucket.value, newBuckets);
                bucket = bucket.next;
            }
        }
    }

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

    public V get(K key) {
        int index = getIndex(key, buckets.length);
        Node<K, V> bucket = buckets[index];
        if (bucket == null) {
            return null;
        }
        while (bucket != null) {
            if (bucket.key.hashCode() == key.hashCode() && (bucket.key == key || bucket.key.equals(key))) {
                return bucket.value;
            }
            bucket = bucket.next;
        }
        return null;
    }

    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < buckets.length; i++) {
            Node<K, V> node = buckets[i];
            while (node != null) {
                if (StringUtils.isNotEmpty(str)) {
                    str.append(",");
                }
                str.append(node.key).append(":").append(node.value);
                node = node.next;
            }
        }
        return str.toString();
    }

    public static void main(String[] args) {
        NewHashMap<String, String> newHashMap = new NewHashMap<>();
        newHashMap.put("a", "111");
        newHashMap.put("b", "222");
        newHashMap.put("c", "333");
        System.out.println(newHashMap.toString());
        System.out.println(newHashMap.get("b"));
    }
}


​