从源码的角度分析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

RHCSA Linux环境搭建

安装Linux操作系统一般有三种方式:为了便捷方便高效,因此本人选择通过虚拟机来使用Linux操作系统。先在官网(Download VMware Workstation Pro)下载好VMware workstation pro软件,下载安装完成后,需要激活打开。下载版本不同,所需激活码也不同(激活码可在网络上查找)

weixin_68256171的博客 1421

深入解析CRC16查表法:从原理到Modbus协议实践

本文深入解析了CRC16查表法的核心原理与实现,重点阐述了其“空间换时间”的优化思想。通过对比直接计算法,详细说明了查表法如何通过预计算表格将计算速度提升数十倍,并提供了完整的Modbus CRC16查表法代码生成、解析及实战避坑指南,帮助开发者在嵌入式及工业通信场景中高效实现可靠的数据校验。

weixin_29166013的博客 558

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

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

a_woxinfeiyang_a的专栏 2939

基于稀疏表示字典学习的图像超分辨率-杨建超论文解析

文章:《Image Super-Resolution via Sparse Representation》 作者:杨建超 信号稀疏的定义: 令字典D的原子个数M,信号维度为N,则有以下三种关系: M = N时,D为完备的; M > N时,D为冗余的; M>>N时, D为过完备的。 图解如下: 借鉴了压缩感知的思想,通过对大量低分辨率图像和高分辨...

ycc18829026593的博客 7638

从源码角度分析-HashMap

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

Ricky_Ling的博客 521

《AI编程实战:深度学习模型改进与系统部署》,改进专栏目录和介绍

专深度学习相关项目都写在本专栏,《一次订阅解锁全部,都有源码,永久观看》,包括车牌识别、股票预测、人脸识别、风格迁移、图像修复、图像超分辨重建、图像分割等任务,Web/PyQt系统实现。引入Transformer、Swin Transformer、DenseNet、ViT、ConvNeXt等算法实战,提供卷积改进,魔改对比实验,模型剪枝,模型蒸馏,模型量化,全网独家整合改进专栏,为不同领域的同学发表论文提供了大力支持。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 3279

【AUTOSAR-IpduM】-2.2-创建并配置一个接收RX的(Multiplexed-I-PDU)多路复用

案列背景: 在CFG中配置一个发送TX的(Multiplexed-I-PDU)多路复用Frame。 目录 1 在Arxml中创建一个发送的多路复用Frame 2 CFG导入带多路复用Frame的ARXML 2.1 CFG中提示的错误Error 2.2 如何解决CFG中提示的错误Error 3 结尾 <--返回「Autosar_BSW高阶配置」总目录--> <--返回「Autosar_BSW高阶配置」专栏主页--> <--返回「个人博客」首页--&g..

「汽车电子助手」的博客 1572

从源码角度分析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

IP-Guard分类管理详解

大家都知道在配置IPGUARD策略前需要做分类库进行设置和分类。 1、应用程序:可以分类,例如上班时间只能用OFFICE和WPS,记事本等办公软件,可以在分类里设置一个类 ;办公软件,在未分类里找到OFFICE,WPS等拖入心建的分类里就可以在配置策略里调用。 2、网站分类也不一样,可以按照自己方式自定义。也可以导入厂家已经收集到的网站分类。 3、邮箱分类:可以提前定义好一个或...

IP-Guard专栏 592

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

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

qq_44717657的博客 797

AI测试入门:基于 RAG 的 LLM 应用程序的测试方法「详细介绍」

一个典型的 RAG 架构包括一个检索器(对知识库进行矢量搜索检索上下文的组件)和一个生成器(从检索器中获取检索上下文以构建提示并生成自定义 LLM 响应作为最终输出的组件)。在大多数情况下, 知识库”由存储在向量数据库(如 ChromaDB)中的向量嵌入组成。

blues_C的博客 1874

innovus:sroute 双层follow pin的做法

根据std cellpower pin的层次可以分成两种情况。

m0_61544122的博客 2735

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

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

dingys的专栏 1051

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

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

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

m0_63432840的博客 307

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

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

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

jinwei__的博客 337

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、付费专栏及课程。

余额充值