HashMap的一些自己的理解

HashMap的一些自己的理解

HashMap是继承了AbstractMap, 实现Map接口, 底层是采用了哈希表(散列表)结构,
既然说道了哈希表, 那就说下哈希表的结构
我们都知道, 数组的特点是占用空间连续, 查询效率高, 增删效率低;链表结构占用空间不连续, 查询效率低, 增删效率高, 我们能不能既查询效率高, 又增删效率也高呢? 为此我们就有了哈希表
哈希表就是结合了数组和链表的优点, 增删查效率高的一种数据结构
HashMap中的结构中含有key和value(键值对), 通过源码我们可以知道

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//哈希码
        final K key;//键
        V value;//值
        Node<K,V> next;//下一个节点
}

一个Node节点里面包含了4部分, 该位置的哈希码, 键, 值, 以及下一个节点对象, 正是因为以上的结构, 才有了哈希表的优点. 下面说下HashMap一些方法:

• put(key, value): 该方法是向Map集合中中添加元素,当向集合中添加一个元素的时候, 首先, 通过hashCode()(该函数底层是通过c语言编写, 在java中通过关键字native来修饰)函数计算该key值的哈希码, 将计算出来的哈希码, 再通过一种散列函数将该hash散列到一个数组中, 散列到到对应的数组下标下, 将其添加到对应的位置下, 判断该位置是否有元素, 如果没有就直接将该节点放在这个位置, 当该位置已有元素时, 就调用equals()方法进行比较该位置和当前的元素是否相同,相同就不添加(保证了HashMap集合的key的唯一性), 不相等就在位置的以链的方式来添加到该位置的末尾, 实现HashMap集合的添加操作.
  补充: 在jdk1.8之前是插入链表的头部的，在jdk1.8中是插入链表的尾部的。
• get(key): 获取集合中的元素, 首先计算key对应的hash值, 接着通过一系列的方法来找到该节点对象node, 而该节点node对象中的value值就是需要查找到值.

---

get()方法的源码:

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;//计算key的hash码,再通过getNode()来获指定的节点Node对象
    }

final Node<K,V> getNode(int hash, Object key) {//通过hash值和对应的key值来查找对应Node对象
        Node<K,V>[] tab; 
        Node<K,V> first, e; 
        int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

接着再说下, HashMap的扩容机制, HashMap位桶的概念, 初始值是16. 在使用过程中该值是可变的. 如果位桶数组中的元素长度达到填充因子的最大值(0.75*数组length), 就会将数组进行扩容.

从JDK1.8开始引入了红黑树, 即当集合中的链表中的节点个数大于8时,就会将链表改为红黑树结构,目的是为了减少查询比较的次数, 下面是java源码定义的中红黑树TreeNode对象.

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 父节点
        TreeNode<K,V> left;//左节点
        TreeNode<K,V> right;//右节点
        TreeNode<K,V> prev;    // 该节点的前一个节点
        boolean red;//树的颜色
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
}

以上是都是自己的理解, 有不足之处还请大家指出.

-----------------------------------------------------------华丽的分割线-----------------------------------------------------------------
20191228更新
手写hashMap, 这次主要是实现HashMap中的put(), get(), size(), isEmpty()
首先定义一个接口MyMap:

public interface MyMap {
    public void put(Object key,Object value);
 
    public Object get(Object key);
    
    public int size();
    
    public boolean isEmpty();
    
    interface Entry{
        public Object getKey();
        public Object getValue();
    }
}

实现类:

package com.wxx.hashmap;

import java.lang.annotation.Target;

public class MyHashMap implements MyMap {
    //默认的数组的长度
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //键值对的数量,Entry的数量
    transient int size;
    //数组的引用,用来指向一个数据,数组的元素都是Entry
    transient Entry[] table = null;

    //无参构造方法
    public MyHashMap() {
        table = new Entry[DEFAULT_INITIAL_CAPACITY];//构造方法中,默认新建一个长度为16的数组
    }

    @Override
    public void put(Object key, Object value) {
        //1.计算hash值
        int hash = key.hashCode();

        //2.计算存储位置,计算需要存到数组中的那个位置
        int index = hash % table.length;

        //3.存储到指定的位置,如果当前的table没有对象就存到数组上
        if (table[index] == null) {
            table[index] = new Entry(key, value, null, hash);//将entry对象放入到数组中
            size++;
        } else {//该数组的位置已经存在了元素, 检查下面的链表是否存在相同的key的Entry对象
            Entry entry = table[index];
            while (entry != null) {
                //比较,找到了就将旧value覆盖,并返回
                if (entry.hash == hash && entry.getKey().equals(key)) {
                    entry.value = value;
                    return;
                }

                //指向下一个节点
                entry = entry.next;
            }
            //如果上面的循环完后都没有找到,那就将这个新节点添加到最前面,不是添加到末尾
            Entry firstEntry = table[index];//原来的第一个节点
            size++;//数量++

            table[index] = new Entry(key, value, firstEntry, hash);//将新节点添加最前面,下一个节点就是原来的第一个节点
        }
    }

    @Override
    public Object get(Object key) {
        //1.计算hash值
        int hash = key.hashCode();
        //2.j计算存储位置
        int index = hash % table.length;

        //这个就是数组某个索引的头节点
        Entry entry = table[index];
        //遍历链表
        while (entry != null) {
            //判断key是否一样,找到了就返回value
            if (entry.hash == hash && entry.key.equals(key)) {
                return entry.value;
            }
            //指向下一个节点
            entry = entry.next;
        }
        //直到最后都没有查到, 就返回null
        return null;
    }

    //打印hashMap
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("{");
        for (Entry entry : table) {
            if (entry != null) {
                while (entry != null) {
                    //追加
                    builder.append(entry.key + "=" + entry.value + ",");
                    //指向下一个节点
                    entry = entry.next;
                }
            }
        }
        //将最后一个","删除,先判断是否有元素
        if (builder.length() > 2) {
            builder.deleteCharAt(builder.length() - 1);
        }

        builder.append("}");
        return builder.toString();
    }
    @Override
    public int size() {
        return size;
    }
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    class Entry implements MyMap.Entry {
        final Object key;
        Object value;
        Entry next;
        int hash;
        public Entry(Object key, Object value, Entry next, int hash) {
            this.key = key;
            this.value = value;
            this.next = next;
            this.hash = hash;
        }

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

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

        @Override
        public String toString() {
            return "Entry{" +
                    "key=" + key +
                    ", value=" + value +
                    ", next=" + next +
                    ", hash=" + hash +
                    '}';
        }
    }
}

测试:

public class Demo {
    public static void main(String[] args) {
        MyMap map = new MyHashMap();
        map.put(23,"china");
        map.put(36,"japan");
        map.put(48,"america");
        map.put(86,"erica");
        map.put(67,"france");
        map.put(23,"itelian");
        map.put(47,"england");

        System.out.println( map.get(23));

        System.out.println(((MyHashMap) map).size);
        System.out.println(map.toString());
    }
}

测试结果: