HashMap源码分析 以及List、Set、Map的讲解 小编会讲的比较细,有问题可以留言

接着讲集合

Java 中List、Set、Map

下面四句话-----------------借鉴地址:http://blog.csdn.net/speedme/article/details/22398395

世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合 

有人想有可以自动扩展的数组,所以有了List 

有的人想有没有重复的数组,所以有了set 

有人想有自动排序的数组,所以有了TreeSet,TreeList,Tree**

 

将这些之前强调一遍他们的所属关系

Collection和Map属于不同树上的元素,所以只有List和Set在Collection下 !!!

所属关系:

1、Collection:

           --List:将以特定次序存储元素。取出来的顺序可能和放入顺序不同。

           --ArrayList / LinkedList / Vector

           --Set : 不能含有重复的元素

                       --HashSet / TreeSet

2、Map

     --HashMap

     --HashTable

     --TreeMap

一、List 有两种

ArrayList和LinkedList 两者区别显而易见,前面的文章也提到了就不讲了。想看的可以打开下面的链接

https://blog.csdn.net/qq_38983577/article/details/81673625

 

二、Set 三种  不允许重复的集合

HashSet 散列类 无序

LinkedHashSet  有序,保持着元素插入的顺序

TreeSet  因为是树所以肯定是有序的

 

三、Map 三种 HashMap、LinkedHashMap、TreeMap

这个Map方面问的比较多的就是HashMap的源码了,

众所周知 在JDK1.8中 HashMap是基于数组、链表、红黑树的

以下参考自 https://www.cnblogs.com/Michaelwjw/p/6411176.html

https://images2015.cnblogs.com/blog/938494/201702/938494-20170217112132097-6544029.png

接下来会从以下几个方面介绍 HashMap 源码相关知识:HashMap 源码相关知识:

  1HashMap 存储结构

  2HashMap 各常量、成员变量作用

  3HashMap 几种构造方法

  4HashMap hash算法

  5HashMap 重要的几个方法

1、存储结构如图,数组、链表、

 

 
 https://images2015.cnblogs.com/blog/938494/201702/938494-20170217113451550-1406894023.png


红黑树(链表长度大于8时转换成红黑树)

 

    2、HashMap 各常量、成员变量作用

    //初始默认大小 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    //HashMap的最大值容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //这就是所谓的装载因子,当 HashMap 中元素数量超过 容量*装载因子 时,进行resize()操作
    //就是超过了这个点就resize()调整大小
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //链表转换成红黑树的临界值,就是超过8变成红黑树
    static final int TREEIFY_THRESHOLD = 8;

    //红黑树转换成链表的临界值
    static final int UNTREEIFY_THRESHOLD = 6;

    /* 当需要将解决 hash 冲突的链表转变为红黑树时,需要判断下此时数组容量,
    若是由于数组容量太小(小于 MIN_TREEIFY_CAPACITY )导致的 hash 冲突太多,
    则不进行链表转变为红黑树操作,转为利用 resize() 函数对 hashMap 扩容 */
    static final int MIN_TREEIFY_CAPACITY = 64;

3、HashMap 几种构造方法

  (1)int,float 参数类型的方法

    public HashMap(int initialCapacity, float loadFactor) {
       //初始容量不能小于零,否则抛异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                    initialCapacity);

	//初始容量不能大于最大值,否则为最大值
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;

	//填充因子必须大于0,且必须为数字
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                    loadFactor);

	//初始化填充因子
        this.loadFactor = loadFactor;

	//初始化threshold大小
        this.threshold = tableSizeFor(initialCapacity);
    }

众所周知这个tableSizeFor(initialCapacity)返回大于initialCapacity的最小的二次幂数值。!!!具体看下文

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

// 无符号右移 高位取0 >>>
java中有三种移位运算符

<<      :     左移运算符,num << n,相当于num乘以2的n次方

>>      :     右移运算符,num >> n,相当于num除以2的n次方

>>>    :     无符号右移,忽略符号位,空位都以0补齐 ,说白了就是右边删n个位,比如 10101111>>>5=101

记住没有无符号左移!!!!

这几行无符号右移写的相当精巧

    n |= n >>> 1;n |= n >>> 2;n |= n >>> 4; n |= n >>> 8;n |= n >>> 16;

依次将输入的值的所有位的变成了1。比如开始的n为 0 1 X X X ->  结束后的为 0 1 1 1 1

然后结尾就是一个嵌套的三目运算符。

n小于0,返回1。

否则若n大于等于最大值容量,则返回最大值容量 MAXIMUM_CAPACITY。

若小于则返回n+1.

刚好实现了返回只大于的 输入值cap 一位的二的幂次方

也就是 众所周知的 tableSizeFor(initialCapacity)返回大于initialCapacity的最小的二次幂数值。

细节可以看这一篇 https://blog.csdn.net/dagelailege/article/details/52972970

(2)int 参数类型的方法

public HashMap(int initialCapacity) {
    // 调用HashMap(int, float)型构造函数
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

(3)无参数类型的方法

public HashMap() {
    // 初始化填充因子
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

(4)Map<...>参数类型的方法

public HashMap(Map<? extends K, ? extends V> m) {
    // 初始化填充因子
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    // 将m中的所有元素添加至HashMap中
    putMapEntries(m, false);
}

  而这个putMapEntries(Map<? extends K, ? extends V> m, boolean evict)函数将m的所有元素存入本HashMap实例中。

 /*注 loadFactor 填充因子 
       MAXIMUM_CAPACITY 最大值容量
       threshold  即前面三目运算那个函数的返回值
   */


 final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
	    //判断table有没有初始化
            if (table == null) { // pre-size
                // 未初始化,s为m的实际元素个数
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                        (int)ft : MAXIMUM_CAPACITY);
                // 计算得到的t大于临界值,则初始化临界值
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
	    //已经初始化后,如果输入的m大于临界值,就进行扩容
            else if (s > threshold)
                resize();
            //将m中元素放入HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

 4、hash算法介绍 拜读博客 :https://www.cnblogs.com/xiaoxi/p/7233201.html

      关于这个hashcode算法小编也总结了一下,

      https://blog.csdn.net/qq_38983577/article/details/81741938

      注(

             ^  -----异或,不相同为1,相同为0

             >>> -----无符号右移,比如 10001101>>>5 = 100

            )

      jdk 1.8的hash算法如下  看不懂可先看后面的重要方法

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

(1)获取对象的hashCode()值,然后将hashCode值右移16位,然后将右移后的值与原来的hashCode做异或运算,返回结果。

至于为啥还有(h = key.hashCode()) ^ (h >>> 16)这个操作???

    你可以百度,我这边知道的答案是 扰动策略,减少碰撞,尽量减少索引落在同一个位置,

      使其均匀分布,那样就可以避免或减少链表的遍历

(2)在putVal源码中,我们通过(n-1)&hash获取该对象的键在hashmap中的位置,算出来的话也就是插入hash数组的位置

         因为&运算的效率高于%运算,运算效率这个就自己去认识一下了。(其中hash的值就是(1)中获得的值)

其中n表示的是hash数组的长度,并且该长度为2的n次方,这样(n-1)&hash就等价于hash%n。

关于为什么等价这里有一篇链接:

https://www.cnblogs.com/ysocean/p/9054804.html

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                boolean evict) {
    ...

    if ((p = tab[i = (n - 1) & hash]) == null)//获取位置
        tab[i] = newNode(hash, key, value, null);
    ...
}

 tab即是table,n是map集合的容量大小,hash是上面方法的返回值。因为通常声明map集合时不会指定大小,或者初始化的时候就创建一个容量很大的map对象,所以这个通过容量大小与key值进行hash的算法在开始的时候只会对低位进行计算,虽然容量的2进制高位一开始都是0,但是key的2进制高位通常是有值的,因此先在hash方法中将key的hashCode右移16位在与自身异或,使得高位也可以参与hash,更大程度上减少了碰撞率。

下面举例说明下,n为table的长度。

5、重要方法分析 

 (1)putVal方法

HashMap并没有直接提供putVal接口给用户调用,我们用的时的put方法,而put方法就是通过putVal来插入元素。

public V put(K key, V value) {
    // 对key的hashCode()做hash 
    return putVal(hash(key), key, value, false, true);  
} 

(2)putVal()方法 来自 https://www.cnblogs.com/xiaoxi/p/7233201.html

①.判断键值对数组table[i]是否为空或为null,否则执行resize()进行扩容;

②.根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向⑥,如果table[i]不为空,转向③;

{

关于这个通过key计算索引的具体过程也就是  上面通过hash算法得到的值‘hash’   ,

然后 (n-1)&hash (也就是等价于hash%n)为啥等价自己看上面的链接

    n是map集合的容量大小则必定是2的幂次方 至于这个容量大小为何是2的幂次方,上面 tableSizeFor方法你可以去看一下

      而 hash则是上面的hash算法得到的值 

而    hash%n 的 余数  是不是就是一个大于0小于等于 n-1的数呢?答案是肯定的 而这个就是索引了

得到的索引

}

③.判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向④,这里的相同指的是hashCode以及equals;

④.判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;

⑤.遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;

⑥.插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 步骤①:tab为空则创建 
    // table未初始化或者长度为0,进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 步骤②:计算index,并对null做处理  
    // (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 步骤③:节点key存在,直接覆盖value 
        // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e,用e来记录
                e = p;
        // 步骤④:判断该链为红黑树 
        // hash值不相等,即key不相等;为红黑树结点
        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;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等,跳出循环
                    break;
                // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 步骤⑥:超过最大容量 就扩容 
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

(3)getNode方法

说明:HashMap同样并没有直接提供getNode接口给用户调用,而是提供的get方法,而get方法就是通过getNode来取得元素的。

public V get(Object key) {
    Node<k,v> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // table已经初始化,长度大于0,根据hash寻找table中的项也不为空
    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;
}

(4)resize方法

①.在jdk1.8中,resize方法是在hashmap中的键值对大于阀值时或者初始化时,就调用resize方法进行扩容;

②.每次扩展的时候,都是扩展2倍;

③.扩展后Node对象的位置要么在原位置,要么移动到原偏移量两倍的位置。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;//oldTab指向hash桶数组
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {//如果oldCap不为空的话,就是hash桶数组不为空
        if (oldCap >= MAXIMUM_CAPACITY) {//如果大于最大容量了,就赋值为整数最大的阀值
            threshold = Integer.MAX_VALUE;
            return oldTab;//返回
        }//如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//新建hash桶数组
    table = newTab;//将新数组的值复制给旧的hash桶数组
    if (oldTab != null) {//进行扩容操作,复制Node对象值到新的hash桶数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {//如果旧的hash桶数组在j结点处不为空,复制给e
                oldTab[j] = null;//将旧的hash桶数组在j结点处设置为空,方便gc
                if (e.next == null)//如果e后面没有Node结点
                    newTab[e.hash & (newCap - 1)] = e;//直接对e的hash值对新的数组长度求模获得存储位置
                else if (e instanceof TreeNode)//如果e是红黑树的类型,那么添加到红黑树中
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;//将Node结点的next赋值给next
                        if ((e.hash & oldCap) == 0) {//如果结点e的hash值与原hash桶数组的长度作与运算为0
                            if (loTail == null)//如果loTail为null
                                loHead = e;//将e结点赋值给loHead
                            else
                                loTail.next = e;//否则将e赋值给loTail.next
                            loTail = e;//然后将e复制给loTail
                        }
                        else {//如果结点e的hash值与原hash桶数组的长度作与运算不为0
                            if (hiTail == null)//如果hiTail为null
                                hiHead = e;//将e赋值给hiHead
                            else
                                hiTail.next = e;//如果hiTail不为空,将e复制给hiTail.next
                            hiTail = e;//将e复制个hiTail
                        }
                    } while ((e = next) != null);//直到e为空
                    if (loTail != null) {//如果loTail不为空
                        loTail.next = null;//将loTail.next设置为空
                        newTab[j] = loHead;//将loHead赋值给新的hash桶数组[j]处
                    }
                    if (hiTail != null) {//如果hiTail不为空
                        hiTail.next = null;//将hiTail.next赋值为空
                        newTab[j + oldCap] = hiHead;//将hiHead赋值给新的hash桶数组[j+旧hash桶数组长度]
                    }
                }
            }
        }
    }
    return newTab;
}

最后一段基本上都是copy的,等小编折回时间一定自己慢慢整理hash,现在太紧了

https://www.cnblogs.com/xiaoxi/p/7233201.html

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Java 中的 ListSetMap 是集合框架中最常用的三种数据结构。它们都是用来存储和操作一组对象的数据结构,但它们之间有一些不同之处。 1. List List 是有序的集合,它可以包含重复的元素。List 可以使用下标来访问它的元素,并且允许插入、删除和修改元素。常用的 List 实现类有 ArrayList 和 LinkedList。ArrayList 是基于数组实现的,适合随机访问和修改元素。LinkedList 则是基于链表实现的,适合插入和删除元素。 2. Set Set 是不允许重复元素的集合,它没有顺序概念。Set 可以用来判断一个元素是否存在于集合中,还可以进行交、并、差等操作。常用的 Set 实现类有 HashSet 和 TreeSet。HashSet 是基于哈希表实现的,适合插入和查找元素。TreeSet 则是基于红黑树实现的,适合排序和范围查找。 3. Map Map 是一种键值对的映射表,它可以用键来访问值,键是唯一的,但值可以重复。Map 可以用来存储配置信息、数据缓存等。常用的 Map 实现类有 HashMap 和 TreeMapHashMap 是基于哈希表实现的,适合快速查找和修改。TreeMap 则是基于红黑树实现的,适合排序和范围查找。 总之,ListSetMap 都是 Java 集合框架中非常重要的部分,每种集合类都有自己的特点和用途,开发者可以根据自己的需求选择适当的集合类。 ### 回答2: Java中的集合是一种用于存储和操作数据的对象容器。在Java中,有三种常用的集合类型:List(列表)、Set(集合)和Map(映射)。 List是有序的,可以存储重复的元素。它的特点是可以按照元素的索引进行访问,也可以根据元素的值进行查找和删除。常用的List实现类有ArrayList和LinkedList。ArrayList使用动态数组实现,适用于随机访问和遍历操作,而LinkedList使用双向链表实现,适用于频繁的插入和删除操作。 Set是无序的,不可以存储重复的元素。它的特点是元素不可重复,且没有固定的顺序。常用的Set实现类有HashSet和TreeSet。HashSet使用哈希表实现,适用于快速的插入和查找操作,而TreeSet使用红黑树实现,可以按照元素的自然顺序进行遍历。 Map是一种键值对的映射结构,存储着键值对的集合。Map不允许重复的键,但允许不同的键对应相同的值。Map的特点是可以通过键快速的查找对应的值。常用的Map实现类有HashMap和TreeMapHashMap使用哈希表实现,适用于快速的查找和插入操作,而TreeMap使用红黑树实现,可以按照键的自然顺序遍历键值对。 总结来说,List是有序的、可重复的集合;Set是无序的、不可重复的集合;Map是键值对的映射结构。根据不同的需求,选择适合的集合类型可以提高代码的效率和可读性。 ### 回答3: Java中的ListSetMap是三种常用的集合类型,它们具有以下特点: 1. List(列表)是有序的集合,可以存储重复的元素。它可以根据元素的索引位置进行访问,支持通过索引添加、删除和修改元素。常见的List实现类有ArrayList和LinkedList。 2. Set(集)是无序的集合,不可以存储重复的元素。它使用哈希表或树结构来存储元素,具有快速查找的特点。常见的Set实现类有HashSet和TreeSet。 3. Map(映射)是一种以键值对形式存储数据的集合。每个键都是唯一的,值可以重复。通过键可以快速查找对应的值。常见的Map实现类有HashMap和TreeMapListSet都是继承自Collection接口,而Map是独立的集合类型。它们都提供了丰富的方法来处理集合中的元素。 ListSet都可以通过Iterator遍历元素,但是List还可以通过索引访问元素。List还可以存储重复的元素,而Set则只能存储唯一的元素。 Map通过键值对来存储和访问元素,可以使用键快速查找对应的值。通过keySet()方法可以获取所有的键,通过values()方法可以获取所有的值。 ListSetMap都是线程不安全的,如果在多线程环境下使用,需要注意线程安全性。可以通过Collections类的synchronizedList、synchronizedSet和synchronizedMap方法将它们转换为线程安全的集合。 总的来说,List适用于需要重复元素并且需要按照顺序访问的场景,Set适用于需要唯一元素的场景,Map适用于需要通过键值对进行存储和访问的场景。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值