从源码的角度分析HashMap

浅析HashMap的实现和性能分析 前段时间面试,被问及hashmap的实现,瞬间蒙了,最后被虐成了狗。痛定思过,发现自己最近一年以来走入了一些歧途,有些本末倒置。故从基础开始,从跌倒的地方开始。 Java集合框架强大、简单、易用。尤其在设计业务逻辑的编程中,集合框架可以说是使用最多的类。Hashmap作为其中一员,是一种把键(key)和值(value)的结构,在实际引用中及其广泛。本篇简单分析java中hashmap的实现,并简 阅读详情

前言
java集合对于java开发来说很重要,而集合中又是以HashMap为重头戏。所以理解HashMap的实现机制就很重要了。
HashMap的数据存储结构,随便一搜就是一大堆,所以就不说了。现在主要是从HashMap源码入手,解析HashMap是如何实现数据的存储的。

  1. 初始化 new HashMap();
    欲练此功,必先自宫。欲使HashMap,必先new 之;
Map<String,String> map=new HsahMap<String,String>();

这是我们最常使用的new 一个HsahMap的方式,那么在new它的时候,它背着我们做了哪些勾当呢,这就需要去看它的构造方法了。

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

代码中发现,其实它就给loadFactory这个参数复制,那么这两个参数是什么呢?接着追踪它的源码。

 final float loadFactor;
 static final float DEFAULT_LOAD_FACTOR = 0.75f;

HashMap默认初始化时,其实就是赋值一个实例参数loadFactory=0.75f。

HashMap初始完以后,就到了给它塞值了,也就是进行put操作。

map.put("keyValue","values");
  1. 第一次塞值 put(“XX”,“XXX”)

接下来看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;
        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;
    }

在源码中可以看出,它做了一系列的判断操作,为了降低读码的难度,现在对代码做一下提取,下面提出来的代码是第一次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;
        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 { }
        ++modCount;
        if (++size > threshold)
           ;
        return null;
    }

经过提取以后,第一次put值时的代码就变的精简了许多。开始逐行解析。

Node<K,V>[] tab; Node<K,V> p; int n, i;

声明一个Node数组,Node变量以及两个int变量。Node究竟是什么呢?下面提出了Node类主要代码。

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;
        }
   }

接着往下看putVal的源码

 transient Node<K,V>[] table;
 if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

将实例变量table的值赋给新new出来的Node数组tab,HashMap在初始化时并为给实例变量table赋值,所以在第一次put时,table=null,也就是说满足条件执行n = (tab = resize()).length;

2.1. HashMap第一次初始化容器大小resize()
resize()源码如下:

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            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
            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];
        table = newTab;
        if (oldTab != null) {
            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)
                        ((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;
                            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;
    }

照例,还是将第一次初始化容器大小执行的代码提取出来方便分析。

 int threshold;
 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) { }
        else if (oldThr > 0) {  };
        else {    
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) { }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {};
        return newTab;
    }

这里一定要抓住第一次,第一次table=null;所以:oldCap =0;oldThr = threshold=0,[threshold是HashMap的一个实例变量。未赋值之前默认为0]。代码往下执行,直到:

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
///////////////////////////////////////////////////////////////
 newCap = DEFAULT_INITIAL_CAPACITY;
 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

这里的赋值用到两个静态常量,我已列举出来。
newCap =1 << 4 即:1<<4 =10000(二进制)=16(十进制)
newThr =int(16X 0.75f)
然后继续往下走

 threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {};
        return newTab;

这里第一次赋值给常量threshold= newThr =int(16X 0.75f);然后new出一个长度为newCap=16的Node数组并给返回。然后我们再回到putVal方法。

n = (tab = resize()).length;

此时 tab=长度为16的Node数组。n=16。到这里初次容易初始化结束,代码接着往下执行

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

这里需要说一下在put时,node数组的下标是如何的出来的,在源码里面可以发现它的计算方法(n - 1) & hash。node数组的长度减一按位与上key值的hash。举例put(“来来来”,“leanHash”);此时key为字符串"来来来",key的hash值为:26283717,转换为二进制:0001100100010000111101010100;此时n=16,那么数组下标i=n-1&hash即:
0001 1001 0001 0000 1111 0101 0100 26283717
0000 0000 0000 0000 0000 0000 1111 15
&
0000 0000 0000 0000 0000 0000 0100 4
可以发现,最后与出来的下标只取决于后四位。换句话来说,就是不管key的hash如何变,经过计算以后,最后得出的下标都是0—15之间的数。

继续回到程序,为什么需要if ((p = tab[i = (n - 1) & hash]) == null)这样判断一下呢?因为这样计算出来的下标可能会出现重复,也就是hash冲突。例如:
0001 1001 0001 0001 1111 0101 0100
0001 1001 0001 0010 1111 0101 0100
0001 1001 0001 0100 1111 0111 0100
这三个hash于上
0000 0000 0000 0000 0000 0000 1111
最后结果都是4。
遇到这样的问题HashMap是如何处理的呢?这个问题后面会说,咱们现在看的是第一次put值的情况,自然就不会存在hash冲突的情况,所以就执行table[i]=tab[i] = newNode(hash, key, value, null)。实例变量table于tab指向的是同一个Node数组。

newNode源码如下:

 Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

new出了一个Node实例。
回到putVal方法继续往下走,到

 ++modCount;
        if (++size > threshold)
            ;
        return null;

modCount自增1,size自增1;threshold 在初始化容器时给它赋值,当时是这样赋值的:threshold= newThr =int(16X 0.75f)。为什么会有这样一个判断呢,这个是因为需要扩容。扩容下面会说,这里不再赘述。至此,第一次put值的操作完成。

  1. 第二次put值至扩容前put值的情况
    同样提取出执行这种情况下执行的代码
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 ((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){}
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        return null;
    }

开始逐步解析:

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
++modCount;
if (++size > threshold)
   resize();
   return null;

计算put的key对应的数组下标,如果当前下标下尚未放值,即为空时,直接newNode(hash, key, value, null)后放在这个位置。modCount自增1;size自增1;(newNode(hash, key, value, null)这个方法之前以说过,就不在重复)。
如果当前下标下已经有数据,即出现hash冲突,hash冲突有两种情况,一种是此时put进来的key之前已经put过,另外一种是key没有put过,经过计算得出的数组位置重复的。现在先来看key已经put过的处理:

 if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
  if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                  e.value = value;
                return oldValue;
            }

代码中可以看出来,当key值重复时,后面的value将覆盖前一个的value覆盖并返回前一个的value;
当key值未put过出现hash冲突的情况:

for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
                return oldValue;
            }
++modCount;
if (++size > threshold)
   resize();
   return null;

这里还是要提一下HashMap的数据存储结构,HashMap存储数据说简单点就是在数组里面放链表。接下来就开始解析上面这段代码。出现hash冲突并且key不重复时,就取这个位置的数据(node),然后判断该node的实例变量next,如果为空,就newNode(hash, key, value, null)new一个Node实例挂上去,完成一个链表。如果next不为空,则验证next里面的key于当前key是否重复,重复就覆盖并返回被覆盖的值。如果key不重复,则一直往下找,直至找到空的next并new新的Node挂上去为止。
计数,当key重复出现覆盖操作时,计数器不变,当出现新的key时,则计数器自增1;
为什么需要计数呢?计数是为了扩容。那么什么是扩容呢?为什么需要扩容呢?

扩容:当HashMap put值的数量大于node数组长度的0.75倍时,HashMap会重新初始化一个新的node数组,这个新的数组长度是原数组的2倍,并将原数组中put过的值移至新的node数组。这个过程就是扩容。

为什么需要扩容?
这里再次提一下HashMap的数据存储结构,HashMap是在数组里面存链表的形式存储数据。这样存储带来的好处是能通过数组下标(hash)快速查找到key所在的链表,进而查找到key所对应的value。假设node数组长度为16,在不扩容的情况下再这个数组里面put 100个key value,那么必然出现很多hash冲突,也就是说数组中存放的链表会越来越长,此时HashMap查找的性能越会越来越低。扩容就能很好解决这样的问题,扩容是一种以内存换效率的做法。

  1. 扩容resize()
    resize()方法完整的源码上面已有,这里提取出来的是非第一次初始化的扩容代码:
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) 
            newCap = oldThr;
        else { }
        if (newThr == 0) { }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            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)
                        ((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;
                            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;
    }

下面开始逐条分析,我以第二次扩容为例来分析

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//长度为16的node数组
        int oldCap = 16;
        int oldThr = 12;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) { }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        threshold = newThr;
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            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) {};
                    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;
                            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;
    }

这段代码中,各种判断满足扩容条件后,新new出了一个长度为32的node数组,并将原来长度为16的node数组中的值移入新的node数组中。
由代码:newCap = oldCap << 1可以看出,每次扩容扩的程度为原数组的2倍 [<<1]左移一位等价于乘以2
老的node数组里面的数据是如何搬到新node数组里面的呢?
if (e.next == null) newTab[e.hash & (newCap - 1)] = e;如果node数组中的node.next==null,也就是说这个位置只存放了一个node数据,不存在链表的情况,直接计算新的数组下边放到相应的位置。

数组中存放链表的情况:

Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
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;
}

代码看着是很简单,可是关于数组下标的计算就有点懵了。先来看一下代码中是如何计算的。j表示老数字中当前位置的数据。代码中,先用hash与老数组长度与运算。计算结果为0,那么这个node数据在新node数组里面的下标与在老数组里面的下标一样;否则,这个node数据在新node素组里面的下标等于老数组的下标加上老数组的数组长度。下面开始来验证一下。
首先我们先找到两个会出现hash冲突的的值
hash1:0001 1001 0001 0000 1111 0100 0100
hash2:0001 1001 0001 0000 1111 0101 0100
node数组长度为16时,他们对应的数组下标,计算公式:hash&(length-1)

hash1
0001 1001 0001 0000 1111 0100 0100 hash1
0000 0000 0000 0000 0000 0000 1111 (length-1)=15
&
0000 0000 0000 0000 0000 0000 0100 4


hash2
0001 1001 0001 0000 1111 0101 0100 hash2
0000 0000 0000 0000 0000 0000 1111 (length-1)=15
&
0000 0000 0000 0000 0000 0000 0100 4

可以看出来,两个hash计算出来的数组下标都为4。

当数组扩容到长度为32时,我们再来计算两个hash对应的数组位置
hash1
0001 1001 0001 0000 1111 0100 0100 hash1
0000 0000 0000 0000 0000 0001 1111 (length-1)=31
&
0000 0000 0000 0000 0000 0000 0100 4


hash2
0001 1001 0001 0000 1111 0101 0100 hash2
0000 0000 0000 0000 0000 0001 1111 (length-1)=31
&
0000 0000 0000 0000 0000 0001 0100 20
由上可知,两个hash在扩容后hash1的位置任然为4,但是hash2的位置变成了20
接下来再来计算hash & length
hash1
0001 1001 0001 0000 1111 0100 0100 hash1
0000 0000 0000 0000 0000 0001 0000 (length)=16
&
0000 0000 0000 0000 0000 0000 0000 0


hash2
0001 1001 0001 0000 1111 0101 0100 hash2
0000 0000 0000 0000 0000 0001 0000 (length)=16
&
0000 0000 0000 0000 0000 0001 0000 不为0

代码中的逻辑是hash & oldLength(16)等于0时,当扩容的32时,数组所在位置保持不见 [hash1] ;否则,当扩容到32时,在新数组中的位置为在原数组里面的位置+原数组的数组长度,即4+16=20 [hash2] 。

  1. 总结
    1:new HashMap()时并没有初始化node数组,只是初始化数组需要的一些参数。到了第一次put操作的时候,才开始初始化node数组。使用默认的初始化,初始化出来的是长度为16的node数组;
    2:当put的key value超过node数组长度的0.75倍时,HashMap会进行扩容操作,扩容的程度为原来的2倍。
    3:经验之谈,在使用HashMap时,应尽量避免HashMap扩容操作,我们可以使用HashMap带参数的构造方法来决定初始化的大小。
链表Node,二叉树TreeNode, 广度优先搜索中压入队列的Node, 字典树中的Node 链表Node这么写 class Node { int val; Node next; public Node(int val) { this.val = val; } } Node节点中有个成员变量val,是整型的,代表这个节点的值。next指针指向的是下一个节点。 二叉树TreeNode class TreeNode { int... 阅读详情

相关推荐

HashMap,ArrayMap,SparseArray 源码角度分析,Android中的数据结构你该如何去选择?

现在随着短视频,抖音,快手的流行NDK模块开发也显得越发重要,需要这块人才的企业也越来越多,随之学习这块的人也变多了,音视频的开发,往往是比较难的,而这个比较难的技术就是NDK里面的技术。音视频/高清大图片/人工智能/直播/抖音等等这年与用户最紧密,与我们生活最相关的技术一直都在寻找最终的技术落地平台,以前是windows系统,而现在则是移动系统了,移动系统中又是以Android占比绝大部分为前提,所以AndroidNDK技术已经是我们必备技能了。

2401_84123188的博客 540

HashMap源码分析(一):JDK源码分析系列

> 正文开始 注:JDK版本为1.8<br> HashMap1.8和1.8之前的源码差别很大 目录 简介 数据结构 类结构 属性 构造方法 增加 删除 修改 总结 1.HashMap简介 HashMap基于哈希表的Map接口实现,是以key-value存储...

chuzhengku0968的博客 416

HashMap,ArrayMap,SparseArray 源码角度分析,Android中的数据结构你该如何去选择?,小白勿进

【Android 详细知识点思维脑图(技能树)】其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。

2401_84148911的博客 841

从源码的角度来谈一谈HashMap的内部实现原理

HashMap可以说是我们一个熟悉又陌生的Java中常用的存储数据的API。说他熟悉,是因为我们经常使用他,而说他陌生是因为我们大部分时间是只知道他的使用,而并不知道他内部的原理,但是在面试考察的时候又最喜欢去问这个原理。今天,我就来从源码的角度,谈谈对HashMap的理解。 HashMap概述 HashMap的底层基于一个数组来进行数据的存储和取出。其继承于Map这个接口来实现,通过put和...

u013637594的博客 1027

使用PyTorch设计卷积神经网络(CNN)来处理遥感图像Indian Pines数据集

使用PyTorch设计卷积神经网络(CNN)来处理遥感图像Indian Pines数据集

XAX520_1314的博客 2491

DeepSeek + 番茄小说:AI辅助小说开发最全指南

DeepSeek与番茄小说合作推出AI辅助小说创作系统,通过DeepSeek的文本生成能力(包括情节构建、角色塑造等)结合番茄小说的市场数据,为作者提供从创意到发布的全流程支持。系统包含智能创意生成器、角色设计、章节自动生成等核心模块,采用数据驱动优化策略,支持128K长文本处理和多风格模仿。开发架构采用Python+FastAPI技术栈,提供分层审核机制确保质量。该系统可帮助作者突破创作瓶颈,提升效率,同时提供订阅制、内容分成等多元变现模式。需注意版权问题和原创性保证。

weixin_41445009的博客 1684

从Java源码的角度来分析HashMap与HashTable的区别

由于HashMap与HashTable都是用来存储Key-Value的键值对,所以经常拿来对比二者的区别,下面就从源码的角度来分析一下HashMap与HashTable的区别,

a_woxinfeiyang_a的专栏 2939

信息收集-服务器信息

服务器上面可以运行大量的系统服务和第三方应用服务,如果操作系统或者第三方软件没有及时升级打补丁,攻击者就有可能直接通过服务器上运行的服务进行攻击。

weixin_49349476的博客 1446

从源码角度分析-HashMap

文章从下面几点去分析HashMap(基于JDK1.8) HashMap的概念 工作原理 hashCode()和equals()的作用分别是什么 扩容机制 1、HashMap的概念 HashMap是基于Map接口实现,以键值对的形式存储,键值允许null值,存储是无序的,非同步的。下面提供官方文档中的描述: Hash table based implementation of th...

Ricky_Ling的博客 521

别再买成品了!手把手教你用0.5mm漆包线DIY高频空芯电感(附计算软件和脱漆技巧)

本文详细介绍了如何用0.5mm漆包线DIY高频空芯电感,涵盖从理论计算到实际绕制的完整流程。通过精确的几何参数控制和专业绕制工艺,读者可以制作出性能优异的高频电感,适用于射频匹配网络、LC谐振电路等场景。文章还提供了计算软件推荐和脱漆技巧,帮助爱好者轻松实现个性化电感制作。

weixin_28738165的博客 115

第3.4章 机器人第三方库实战总结(四):G2O优化库从入门到实战(附SLAM实例代码)

自定义边同样是满足复杂应用需求的重要手段。自定义边时,需要明确边所连接的顶点类型以及边所表示的误差项的计算方式。假设我们要定义一条边,用于约束两个上述自定义顶点之间的相对位姿和传感器偏移量关系。我们可以这样定义边类:public:// 计算误差// 计算雅可比矩阵// 读盘和存盘函数,这里暂不实现。

行知SLAM 363

从源码角度分析HashMap的get和put方法

getNode方法接收两个参数,第一个参数是key的hash值,第二个参数就是key本身,get方法是通过该方法去获取Node,从而获取到Node的value。put方法的作用是将一对key-value插入到HashMap中,若HashMap中已经存在这个key,则用新的value替换旧的value。get方法的作用是传入我们所需要获取的节点的key,然后将这个节点的value返回。新节点采用"头插法"插入(JDK1.7),JDK1.8改为"尾插法"是HashMap的主体结构,称为"哈希表"或"桶数组"

qq_74202612的博客 274

RK3568 上C图像camera图像采集应用实例(二)

本文探索rk3568上实现C语言的 通过C v4l2 接口 采集图像 ,刷屏控制 drm的显示camera图像中 实现camera preview 预览 的实践和探索。

luoshanxuli2010的专栏 763

从源码角度分析如何遍历HashMap

从HashMap源码了解如何遍历HashMap 遍历HashMap

qq_44717657的博客 797

抖音创作者必备工具!免费一键批量下载无水印视频 + 一键提取抖音视频文案

抖音创作者必备工具!免费一键批量下载无水印视频 + 一键提取抖音视频文案

XiaoqiangClub的博客 3367

AIGC算法工程师 面试八股文

1、简述DDPM的算法原理 2、什么是重参数化技巧?Diffusion Models和VAE中的重参数化技巧是如何使用的? VAE中的重参数化技巧 Diffusion Models中的重参数化技巧 3、什么是马尔可夫过程?DDPM中的马尔可夫链是如何定义的? 马尔可夫过程 DDPM马尔可夫链 4、为什么DDPM前向过程中前期加噪少,后期加噪多? 5、VAE和Diffusion Models中的变分推断是什么? 6、Negative Prompt实现的原理是什么?

沉迷单车的追风少年 1万+

HashMap从源码角度分析遍历过程

上一篇分析了HashMap的数据结构以及put方法的源码 HashMap源码解析,下面分析HashMap的遍历过程的源码。 遍历的方法有很多中,主要分析下面这种: Iterator<Map.Entry<String, String>> iterator = hashMap.entrySet().iterator(); while (iterator.hasNex

dingys的专栏 1051

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

从源码角度分析 如何向hashmap中put一个值

在源码分析之前,首先我们来说说哈希冲突。在Java中,哈希表使用哈希码来确定存储对象的位置。哈希码不同,则一定表示不同的对象。

m0_63432840的博客 307

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Java面试之从源码的角度分析Hashtable和HashMap

引言面试中我们经常被问到这样的问题:”请说说Hashtable和HashMap的区别?”。 通过搜索引擎,我们能轻易找到 许多答案。这些答案详细比较了两者的不同。但是往往停留在”知其然“的阶段,只是用文字列出了两者的不同。因此,等过一些日子我们再来回顾这个问题 时,似乎一切又归零了(至少对于记忆不好的我来说是这样的)。今天,我打算从源码的角度来分析分析它们的区别,做到不仅”知其然“,更能”知其所以

jinwei__的博客 337

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

HashMap与HashTable的区别源码角度分析

1.首先分析HashMap HashMap 的数据结构为数组加链表,即哈希表,刚创建为数组形式,当添加元素足够多时hash运算之后元素存储位置可能相同,就会形成链表。 new一个HashMap点击进入查看源码 HashMap<String,String> hashMap=new HashMap(); hashMap.put(“aa”,“aaa”); hashmap没有加锁所以线程不安全,效率高 默认初始容量16(1<<4=16),最大容量1073741824(1<<3

weixin_45332076的博客 316

从源码的角度分析Hashtable和HashMap的区别

引言 面试中我们经常被问到这样的问题:”请说说Hashtable和HashMap的区别?”。 通过搜索引擎,我们能轻易找到 许多答案。这些答案详细比较了两者的不同。但是往往停留在”知其然“的阶段,只是用文字列出了两者的不同。因此,等过一些日子我们再来回顾这个问题 时,似乎一切又归零了(至少对于记忆不好的我来说是这样的)。今天,我打算从源码的角度来分析分析它们的区别,做到不仅”知其然“,更能”

jinrall的专栏 673

从源码角度分析HashMap中的put方法的基本流程

而其他的分别是我们调用put方法时的key,value的值。在return的时候使用了一个三元运算符,先进行了一次null值判断,如果key值为null则直接返回0,否则,先对变量h赋值为key的hashCode值,并将h右移16位,这个右移的操作叫做扰动函数,是为了让我们hashCode中的值更分散,减少hash冲突。HashMap是我经常会用到的一个很实用的类,之前用的时候只是知道HashMap的复杂度是log(1),很方便查找,多次使用之后决定来分析一下源码,多了解一下这个类的细节。

weixin_54087697的博客 302

HashMap的源码分析与实现 伸缩性角度看hashmap的不足

本文介绍 1.hashmap的概念 2.hashmap的源码分析 3.hashmap的手写实现 4.伸缩性角度看hashmap的不足 一.HashMap的概念 HashMap可以将其拆分为Hash散列和map两部分来理解; Hash散列是将一个任意长度的通过某种算法转化成为一个固定的值, map地图x,y存储 存储结构为:<key,valu...

weixin_30597269的博客 204

源码角度分析HashMap与HashTable到底哪不同?

在网上看到一篇较好的文章,分享出来,其中有些地方加上了自己的理解。HashMap和HashTable有什么不同?在面试和被面试的过程中,我问过也被问过这个问题,也见过了不少回答,下次被问到时,再也不会只说一个线程安全,一个非线程安全了,而是一撸袖子:闪开,老衲要装逼了!代码版本JDK每一版本都在改进。本文讨论的HashMap和HashTable基于JDK 1.7.0_67。1、时间HashTable

Lovnx 917

HashMap详解:从源码角度逐步分析(底层实现原理,扩容机制)

负载因子的作用是如果数组的使用率很高,那么链表(红黑树)的长度(高度)就会很长,这样查找的效率就会很低,扩容以后,将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置,这样就减少了链表的长度,提高了查询效率。,这也就意味着,当数组中的元素达到了一半就开始扩容,既然填充的元素少了,Hash冲突也会减少,那么底层的链表长度或者是红黑树的高度就会降低。,空间利用率比较高,而且避免了相当多的Hash冲突,使得底层的链表或者是红黑树的高度比较低,提升了空间效率。负载因子是0.75的时候。

Amilieier的博客 362
上一篇: 执行update语句后返回update更新的结果集
下一篇: TreeMap的fixAfterInsertion方法调用流程
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

搬砖工-->攻城狮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值