这篇文章是整理下Map的相关知识。

 

 

  • 首先先了解下Map 子类
  • HashMap原理 概念 和底层架构
  •  

Map 实现类关系 与 实现类特点

 

Map  -  HashTable

         -  HashMap

         -  SortedMap -  TreeMap

HashTable : 底层Hash数表结构，不可以存入null 键 和 null 值，该集合是现成同步。执行效率慢

hashMap :   可以存入null 键 null 值，执行为异步操作，线程不安全，执行效率高

TreeMap :   底层二叉树结构，线程不同步，可以给集合中key进行排序。实现

 

 

HashMap原理 概念 底层架构

平常开发中，已经使用过HashMap无数次，但是真的熟悉HashMap具体工作原理吗？

学习HashMap 之前，我们需要先复习两个数据结构。

数组

优点：连续的内存存储，可以通过下标快速寻址

切点：插入困难

单链表

优点：插入删除的操作比较容易。

缺点：内存离散存储，寻址比较困难。

HashMap 总结来说是一个容器，进行存储数据的，那怎么进行快速 增删改查的呢？

  • 这里概念的描述下HashMap中使用到数据结构，和一部分工作原理。
  • 初始数组，单向链表，红黑树（特殊的二叉树 均衡的二叉树结构）
  • 存入数据的时候回使用 key%size 的方式插入数据。
  • 当存入多个 key%size 的 角标值相同，但key 值不同时（ 发生了冲突），会以链表的形式挂数组初始化位置的后面。
  • 当某个节点的后面元素过多时，会转化成红黑树的以提高效率。（1.8JDK）

从源码进行分析

第一步，我创建一个HashMap ，并且手动存入一个值

HashMap<String, String> map = new HashMap();
        map.put("1", "a");
         
1、 进入HsahMap 的构造函数发现仅仅是一个复制操作
       
        public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
        }

1.1、 static final float DEFAULT_LOAD_FACTOR = 0.75f;// 负载因子

2、 从 put 进入源码，看到先计算 可以的hash值，
    
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }


    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

     
2.1、查看putVal方法，发现table这个属性，
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2.2、 transient Node<K,V>[] table; // 查看得知table 是一个数组

2.3、查看Node ， next 明显一个链表结构 

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

那么就总结一下：table变量为HashMap的底层数据结构，用于存储添加到HashMap中的Key-value对，是一个Node数组，Node是一个静态内部类