学不会的HashMap（二）

最新推荐文章于 2022-11-21 14:41:18 发布
最新推荐文章于 2022-11-21 14:41:18 发布
阅读量210 收藏
点赞数
分类专栏： # Java 集合 文章标签： 数据结构 hashmap java java map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D_A_I_H_A_O/article/details/109221419
版权

学不会的HashMap（一）

插入

HashMap插入数据简单来说就是通过你的Key值取得哈希再计算下标，之后把相应的数据存放到里面。

疑问

  • 如果出现哈希值计算的下标碰撞了怎么办
  • 如果碰撞了是扩容数组还是把值存成链表结构，让一个节点有多个值存放呢
  • 如果存放的数据的链表过长，就失去了散列表的性能了，怎么办呢？
  • 如果想解决链表过长，什么时候使用树结构呢，使用哪种树呢？

HashMap插入数据流程图

在这里插入图片描述
具体如下；

1、首先进行哈希值的扰动，获取一个新的哈希值。(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

2、判断tab是否为空或者长度为0，如果是则进行扩容操作。

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

3、根据哈希值计算下标，如果对应下标正好没有存放数据，则直接插入即可否则需要覆盖。tab[i = (n - 1) & hash])

4、判断tab[i]是否为树节点，否则向链表中插入数据，是则向树中插入节点。

5、如果链表中插入节点的时候，链表长度大于等于8，则需要把链表转换为红黑树。treeifyBin(tab, hash);

6、最后所有元素处理完成后，判断是否超过阈值；threshold，超过则扩容。

7、treeifyBin,是一个链表转树的方法，但不是所有的链表长度为8后都会转成树，还需要判断存放key值的数组桶长度是否小于64 MIN_TREEIFY_CAPACITY。如果小于则需要扩容，扩容后链表上的数据会被拆分散列的相应的桶节点上，也就把链表长度缩短了。

可见 HashMap链表转化红黑树的最大长度居然不是8？？？

HashMap插入数据源码

JDK1.8 HashMap的put方法源码如下:

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 初始化桶数组 table，table 被延迟到插入新数据时再进行初始化
    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;
        // 如果键的值以及节点 hash 等于链表中的第一个键值对节点时，则将 e 指向该键值对
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
            
        // 如果桶中的引用类型为 TreeNode，则调用红黑树的插入方法
        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;
                }
                
                // 条件为 true，表示当前链表包含要插入的键值对，终止遍历
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        
        // 判断要插入的键值对是否存在 HashMap 中
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 键值对数量超过阈值时，则进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

扩容机制

HashMap是基于数组+链表和红黑树实现的，但用于存放key值得的数组桶的长度是固定的，由初始化决定。

jdk1.8中的优化操作，可以不需要再重新计算每一个元素的哈希值，这在上一章节中已经讲到

扩容的代码(注释部分)；

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // Cap 是 capacity 的缩写，容量。如果容量不为空，则说明已经初始化。
    if (oldCap > 0) {
        // 如果容量达到最大1 << 30则不再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        
        // 按旧容量和阀值的2倍计算新容量和阀值
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
    
        // initial capacity was placed in threshold 翻译过来的意思，如下；
        // 初始化时，将 threshold 的值赋值给 newCap，
        // HashMap 使用 threshold 变量暂时保存 initialCapacity 参数的值
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 这一部分也是，源代码中也有相应的英文注释
        // 调用无参构造方法时，数组桶数组容量为默认容量 1 << 4; aka 16
        // 阀值；是默认容量与负载因子的乘积，0.75
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    
    // newThr为0，则使用阀值公式计算容量
    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"})
        // 初始化数组桶，用于存放key
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 如果旧数组桶，oldCap有值，则遍历将键值映射到新数组桶中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    // 这里split，是红黑树拆分操作。在重新映射时操作的。
                    ((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;
                    // 这里是链表，如果当前是按照链表存放的，则将链表节点按原顺序进行分组
                    //{这里有专门的文章介绍，如何不需要重新计算哈希值进行拆分《HashMap核心知识，扰动函数、负载因子、扩容链表拆分，深度学习》}
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    
                    // 将分组后的链表映射到桶中
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

链表树化

HashMap这种散列表的数据结构，最大的性能在于可以O(1)时间复杂度定位到元素，但因为哈希碰撞不得已在一个下标里存放多组数据，那么jdk1.8之前的设计只是采用链表的方式进行存放，如果需要从链表中定位到数据时间复杂度就是O(n)，链表越长性能越差。因为在jdk1.8中把过长的链表也就是8个，优化为自平衡的红黑树结构，以此让定位元素的时间复杂度优化近似于O(logn)，这样来提升元素查找的效率。但也不是完全抛弃链表，因为在元素相对不多的情况下，链表的插入速度更快，所以综合考虑下设定阈值为8才进行红黑树转换操作。

链表转红黑树，如下图：
在这里插入图片描述
以上就是一组链表转换为红黑树的情况，元素包括；40、51、62、73、84、95、150、161 这些是经过实际验证可分配到Idx：12的节点

通过这张图，基本可以有一个链表换行到红黑树的印象，接下来阅读下对应的源码。

链表树化源码

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 这块就是我们上面提到的，不一定树化还可能只是扩容。主要桶数组容量是否小于64 MIN_TREEIFY_CAPACITY 
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
    	// 又是单词缩写；hd = head (头部)，tl = tile (结尾)
        TreeNode<K,V> hd = null, tl = null;
        do {
            // 将普通节点转换为树节点，但此时还不是红黑树，也就是说还不一定平衡
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            // 转红黑树操作，这里需要循环比较，染色、旋转。关于红黑树，在下一章节详细讲解
            hd.treeify(tab);
    }
}

以上源码主要包括的知识点如下；

  • 链表树化的条件有两点；链表长度大于等于8、桶容量大于64，否则只是扩容，不会树化。
  • 链表树化的过程中是先由链表转换为树节点，此时的树可能不是一颗平衡树。同时在树转换过程中会记录链表的顺序，tl.next = p，这主要方便后续树转链表和拆分更方便。
  • 链表转换成树完成后，在进行红黑树的转换。先简单介绍下，红黑树的转换需要染色和旋转，以及比对大小。在比较元素的大小中，有一个比较有意思的方法，tieBreakOrder加时赛，这主要是因为HashMap没有像TreeMap那样本身就有Comparator的实现。

红黑树转链

在链表转红黑树中我们重点介绍了一句，在转换树的过程中，记录了原有链表的顺序。

那么，这就简单了，红黑树转链表时候，直接把TreeNode转换为Node即可，源码如下；

final Node<K,V> untreeify(HashMap<K,V> map) {
    Node<K,V> hd = null, tl = null;
    // 遍历TreeNode
    for (Node<K,V> q = this; q != null; q = q.next) {
    	// TreeNode替换Node
        Node<K,V> p = map.replacementNode(q, null);
        if (tl == null)
            hd = p;
        else
            tl.next = p;
        tl = p;
    }
    return hd;
}

// 替换方法
Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
    return new Node<>(p.hash, p.key, p.value, next);
}

因为记录了链表关系，所以替换过程很容易。所以好的数据结构可以让操作变得更加容易。

查找

HashMap查找数据流程图

在这里插入图片描述

HashMap查找数据源码

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;
    // 判断桶数组的是否为空和长度值
    if ((tab = table) != null && (n = tab.length) > 0 &&
        // 计算下标，哈希值与数组长度-1
        (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) {
            // TreeNode 节点直接调用红黑树的查找方法，时间复杂度O(logn)
            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;
}
  • 扰动函数的使用，获取新的哈希值，这在上一章节已经讲过
  • 下标的计算，同样也介绍过 tab[(n - 1) & hash])
  • 确定了桶数组下标位置，接下来就是对红黑树和链表进行查找和遍历操作了

删除

HashMap删除数据源码

ublic V remove(Object key) {
     Node<K,V> e;
     return (e = removeNode(hash(key), key, null, false, true)) == null ?
         null : e.value;
 }
 
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    // 定位桶数组中的下标位置，index = (n - 1) & hash
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        // 如果键的值与链表第一个节点相等，则将 node 指向该节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            // 树节点，调用红黑树的查找方法，定位节点。
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                // 遍历链表，找到待删除节点
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        
        // 删除节点，以及红黑树需要修复，因为删除后会破坏平衡性。链表的删除更加简单。
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

删除的操作也比较简单，这里面都没有太多的复杂的逻辑。另外红黑树的操作因为被包装了，只看使用上也是很容易。

遍历

KeySet 遍历key

 for (String key : map.keySet()) {
     System.out.print(key + " ");
 }

EntrySet 遍历键值对

 for (HashMap.Entry entry : map.entrySet()) {
     System.out.print(entry + " ");
 }

从方法上以及日常使用都知道，KeySet是遍历是无序的，但每次使用不同方式遍历包括keys.iterator()，它们遍历的结果是固定的。

那么从实现的角度来看，这些种遍历都是从散列表中的链表和红黑树获取集合值，那么他们有一个什么固定的规律吗？

代码测试

测试的场景和前提

  • 这里我们要设定一个既有红黑树又有链表结构的数据场景
  • 为了可以有这样的数据结构，我们最好把HashMap的初始长度设定为64，避免在链表超过8位后扩容，而是直接让其转换为红黑树。
  • 找到18个元素，分别放在不同节点(这些数据通过程序计算得来)；
    • 桶数组02节点：24、46、68
    • 桶数组07节点：29
    • 桶数组12节点：150、172、194、271、293、370、392、491、590
@Test
public void test_Iterator() {
    Map<String, String> map = new HashMap<String, String>(64);
    map.put("24", "Idx：2");
    map.put("46", "Idx：2");
    map.put("68", "Idx：2");
    map.put("29", "Idx：7");
    map.put("150", "Idx：12");
    map.put("172", "Idx：12");
    map.put("194", "Idx：12");
    map.put("271", "Idx：12");
    System.out.println("添加元素，在HashMap还是只链表结构时，输出测试结果01：");
    for (String key : map.keySet()) {
        System.out.print(key + " ");
    }
    //24 46 68 29 150 172 194 271 
    
    map.put("293", "Idx：12");
    map.put("370", "Idx：12");
    map.put("392", "Idx：12");
    map.put("491", "Idx：12");
    map.put("590", "Idx：12");
    System.out.println("\n\n添加元素，在HashMap转换为红黑树时候，输出测试结果02：");
    for (String key : map.keySet()) {
        System.out.print(key + " ");
    } 
    //24 46 68 29 271 150 172 194 293 370 392 491 590    
    
    map.remove("293");
    map.remove("370");
    map.remove("392");
    map.remove("491");
    map.remove("590");
    System.out.println("删除元素，在HashMap转换为链表结构时，输出测试结果03");
    for (String key : map.keySet()) {
        System.out.print(key + " ");
    }
    //24 46 68 29 172 271 150 194 
}

从map.keySet()测试结果可以看到，如下信息；

  • 第一种情况下，排序定位哈希值下标和链表信息
    在这里插入图片描述
  • 第二种情况下，因为链表转换为红黑树，树根会移动到数组头部。moveRootToFront()方法

在这里插入图片描述
*第3中情况下，因为删除了部分元素，红黑树退化成链表。

在这里插入图片描述
在这里插入图片描述
bugstack虫洞栈

DAIHAO丶
关注
专栏目录
一文就懂HashMap原理！学不会你来砍我！
流楚丶格念的博客
08-12 2307
HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null（但是key的位置只能有一个null），此外，HashMap 中的映射不是有序的。好，我们根据这里的简介看一个入门例子： 运行结果如下所示：这里的HashMap我是用的jdk8的，jdk1.7及以前和jdk1.8 及以后的HashMap是有很大区别的：下面我们说的HashMap都是jdk1.8 及
HashMap源码分析学习
weixin_44961794的博客
06-16 179
Java为数据结构中的映射定义了一个接口java.util.Map，此接口主要有四个常用的实现类，分别是HashMap、Hashtable、LinkedHashMap和TreeMap，类继承关系如下图所示： 下面针对各个实现类的特点做一些说明： (1)HashMap：它根据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定...
java集合之HashMap源码分析(常用函数，扩容，哈希冲突，线程不安全问题，HashSet)
一名正在成长的程序员
02-17 1487
深入理解HashMap
HashMap源码分析
和大黄的博客
02-24 8558
1、hashmap的数据结构 要知道hashmap是什么，首先要搞清楚它的数据结构，在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，hashmap也不例外。Hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列“），请看下图（横排表示数组，纵排表示数组元素【实际上是一个链表】）。 上图中，X轴方向为HashMap的数组容器，Y轴方向，为每个相应位置的单向链表。每一个元素都是一个包含如图所示四个属性，k
Java集合之HashMap源码分析
weixin_30779691的博客
01-02 94
以下源码均为jdk1.7 HashMap概述 HashMap是基于哈希表的Map接口的非同步实现. 提供所有可选的映射操作, 并允许使用null值和null健. 此类不保证映射的顺序. 需要注意的是: HashMap不是同步的. 哈希表 哈希表定义: 哈希表是一种根据关键码去寻找值的数据映射结构, 该结构通过把关键码映射的位置去寻找存放值的地方. 举个例子, 最典型的例子就是字典, 如...
赋值运算符重载函数
饺子的专栏
07-06 1209
问题：给出如下CMyString的声明，要求为该类型添加赋值运算符函数。 class CMyString{public:    CMyString(char* pData = NULL);    CMyString(const CMyString& str)
（2.1.8.3）HashMap源码分析
JAVA成长之路
08-06 740
哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑 JDK 1.8 以前哈希表通过数组+链表的方式实现 重写equals方法需同时重写hashCode方法 JDK 1.8 以后哈希表的 添加、删除、查找、扩容方法...
HashMap学习心得
weixin_44588693的博客
07-18 241
学习HashMap底层逻辑心得
Hashmap学习文章
最新发布
MrOrange2018的博客
11-21 83
HashMap　详解
HashMap
qq_38425704的博客
06-11 191
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
通俗易懂Hashmap源码解析
xadasss的博客
05-14 6580
Hashmap源码解析 一、Hashmap数据结构 哈希表是一种以键 - 值（key-value）存储数据的结构，我们只要输入待查找的值即 key，就可以找到其对应的值即 Value。哈希的思路很简单，把值放在数组里，用一个哈希函数把 key 换算成一个确定的位置，然后把 value 放在数组的这个位置。 比如上图中，一共有13个桶0-12，当哈希值是01时，就会被放到1桶中，如果是14，对13取模之后也是1，所以也会被放到1桶中。由于1桶有两个数据，就会形成一个链表。 这里需要注意的是，如果链表大小超
Java集合框架之三：HashMap源码解析
weixin_30915275的博客
02-24 94
版权声明：本文为博主原创文章，转载请注明出处，欢迎交流学习！ HashMap在我们的工作中应用的非常广泛，在工作面试中也经常会被问到，对于这样一个重要的集合模型我们有必要弄清楚它的使用方法和它底层的实现原理。HashMap是通过key-value键值对的方式来存储数据的，通过put、get方法实现键值对的快速存取，这是HashMap最基本的用法。HashMap底层是通过数组和链...
HashMap源码解析
A08110123的博客
09-13 152
hashMap数据结构图： HashMap特点： 允许一个记录的键为null; 允许多条记录的值为null; 非线程安全，任意时刻多线程操作hashmap，有可能导致数据不一致，可以通过Collections的synchronizedMap来实现Map的线程安全或者使用concurrentHashMap。 HashMap是链表+数组...
Thinking in Java之HashMap源码分析
weixin_34203832的博客
05-05 110
欢迎讨论、交流，转载请注明出处，3Q! 前言 在前面的文章中笔者就Map接口和Map接口的实现原理:内部哈希映射技术做了一个简单的 分析，并且对hashCode方法做了一些阐述。可能有些混乱，不过理解这些是弄懂HashMap 的前提，也能帮助我们更好的解析has...
python代码规范软件_5种带你轻松分析Python代码的软件库
weixin_42365804的博客
12-30 108
【51CTO.com快译】通常，人们会使用两种速度来衡量某种编程语言的优劣，即：开发速度和执行速度。对于Python而言，大家往往受益的是它能够快速地编写代码，而忽略了它是否能够快速地运行，并及时完成既定的任务。因此，在出现程序运行缓慢时，我们有必要从代码层面上，找出拖慢的位置和原因，并对其进行处理。好消息是，Python提供了许多不同用途的软件库，可方便我们对应用代码进行分析，并找出导致缓慢运行...
链表重载等号_结点类 等号 重载问题
weixin_39789499的博客
12-23 215
voidList::dxu(Node*head)//倒叙排列一个链表{按数据结构结点链表类来做的}{Node*p,pnow,q;p=head->next;if(p==NULL)return;pnow=NULL;while(p->next){q=p->next;p->next=pnow;pnow=p...void List:: dxu(Node * head)//倒叙排列一个...
hashmap源码解读
zyc8715150的博客
04-23 260
hashmap扩容源码解读 一、四个构造行函数 1.设置初始化大小，以及负载因子（threshold（阀值）=initialCapacity*loadFactor） 阀值：超出这个大小则会扩容。 最后，tableSizeFor():找到大于等于initialCapacity，且是2的次方，这个算法还是比较牛逼的，里面的逻辑是，初始化大小减去1，找到最大位数的1，将他无符号向右移动5次，如5，减去...
HashMap的源码分析
leofee的博客
01-18 905
文章目录前言一、HashMap重要的几个属性二、HashMap源码分析1. HashMap的初始化2.HashMap容量为什么要设置为2的幂次方整数3. HashMap的哈希算法4. HashMap添加元素的过程5. HashMap的扩容机制JDK1.7 中HashMap添加元素导致死循环1.8 对HashMap的改进HashMap和HashTable的区别 前言 HashMap实现于Map接口，是一种存储key-value对的容器。 底层数据结构为哈希表，数组，链表，红黑树（当链表的长度大于等8时，链表
Java学习路线：从基础到进阶
- **Java集合框架**：包括ArrayList、LinkedList、HashSet、HashMap等数据结构，它们是处理和存储对象的主要工具。 - **Java IO**：涉及输入/输出流，用于读写文件、网络通信等。 - **JDBC**：Java数据库连接，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值