Java容器之HashMap源码剖析(JDK1.7)

已于 2022-08-09 10:20:04 修改
阅读量175 收藏 1
点赞数 1
分类专栏： java 文章标签： java 哈希算法 数据结构
于 2019-08-30 18:25:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43691098/article/details/100157141
版权

写在前面：
本文基于JDK1.7
我们知道Hash的底层是散列表，而在Java中散列表的实现是通过数组+链表的~
关于散列表相关知识可参考：https://blog.csdn.net/weixin_43691098/article/details/99846250

目录

1.使用与实现

1.1 基本使用

HashMap很方便地为我们提供了key-value的形式存取数据，使用put方法存数据，get方法取数据。

Map<String, String> hashMap = new HashMap<String, String>();
hashMap.put("name", "josan");
String name = hashMap.get("name");

1.2 定义

HashMap继承了Map接口，实现了Serializable等接口。

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{
    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table;

其实HashMap的数据是存在table数组中的，它是一个Entry数组，Entry是HashMap的一个静态内部类，看看它的定义。

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

可见，Entry其实就是封装了key和value，也就是我们put方法参数的key和value会被封装成Entry，然后放到table这个Entry数组中。但值得注意的是，它有一个类型为Entry的next，它是用于指向下一个Entry的引用，所以table中存储的是Entry的单向链表。默认参数的HashMap结构如下图所示：
在这里插入图片描述

1.3 构造方法

HashMap一共有四个构造方法，我们只看默认的构造方法。

 /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }


    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // 找到第一个大于等于initialCapacity的2的平方的数
        int capacity = 1; 
        while (capacity < initialCapacity)
            capacity <<= 1;//相当于capacity = capacity << 1 将capacity 的二进制位左移1位，右补0

        this.loadFactor = loadFactor;
        // HashMap扩容的阀值，值为HashMap的当前容量 * 负载因子，默认为12 = 16 * 0.75
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        // 初始化table数组，这是HashMap真实的存储容器
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        // 该方法为空实现，主要是给子类去实现
        init();
    }

initialCapacity是HashMap的初始化容量(即初始化table时用到)，默认为16。

oadFactor为负载因子，默认为0.75。

threshold是HashMap进行扩容的阀值，当HashMap的存放的元素个数超过该值时，会进行扩容，它的值为HashMap的容量乘以负载因子。比如，HashMap的默认阀值为16*0.75，即12。

HashMap提供了指定HashMap初始容量和负载因子的构造函数，这时候会首先找到第一个大于等于initialCapacity的2的平方数，用于作为初始化table。至于为什么HashMap的容量总是2的平方数，后面会说到。

继续看HashMap构造方法，init是个空方法，主要给子类实现，比如LinkedHashMap在init初始化头部节点，这里暂时先不介绍。

1.4 put方法

public V put(K key, V value) {
        // 对key为null的处理
        if (key == null)
            return putForNullKey(value);
        // 根据key算出hash值
        int hash = hash(key);
        // 根据hash值和HashMap容量算出在table中应该存储的下标i
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 先判断hash值是否一样，如果一样，再判断key是否一样
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

首先，如果key为null调用putForNullKey来处理，我们暂时先不关注，后面会讲到。然后调用hash方法，根据key来算得hash值，得到hash值以后，调用indexFor方法，去算出当前值在table数组的下标，我们可以来看看indexFor方法：

static int indexFor(int h, int length) {
        return h & (length-1);
    }

这其实就是mod取余的一种替换方式，相当于h%(lenght-1)，其中h为hash值，length为HashMap的当前长度。而&是位运算，效率要高于%。至于为什么是跟length-1进行&的位运算，是因为length为2的幂次方，即一定是偶数，偶数减1，即是奇数，这样保证了（length-1）在二进制中最低位是1，而&运算结果的最低位是1还是0完全取决于hash值二进制的最低位。如果length为奇数，则length-1则为偶数，则length-1二进制的最低位横为0，则&位运算的结果最低位横为0，即横为偶数。这样table数组就只可能在偶数下标的位置存储了数据，浪费了所有奇数下标的位置，这样也更容易产生hash冲突。这也是HashMap的容量为什么总是2的平方数的原因。我们来用表格对比length=15和length=16的情况

在这里插入图片描述
我们再回到put方法中，我们已经根据key得到hash值，然后根据hash值算出在table的存储下标了，接着就是这段for代码了：

for (Entry<K,V> e = table[i]; e != null; e = e.next) {
     Object k;
     // 先判断hash值是否一样，如果一样，再判断key是否一样
     if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
         V oldValue = e.value;
         e.value = value;
         e.recordAccess(this);
         return oldValue;
     }
 }

首先取出table中下标为i的Entry，然后判断该Entry的hash值和key是否和要存储的hash值和key相同，如果相同，则表示要存储的key已经存在于HashMap，这时候只需要替换已存的Entry的value值即可。如果不相同，则取e.next继续判断，其实就是遍历table中下标为i的Entry单向链表，找是否有相同的key已经在HashMap中，如果有，就替换value为最新的值，所以HashMap中只能存储唯一的key

关于需要同时比较hash值和key有以下两点需要注意

  1. 为什么比较了hash值还需要比较key：因为不同对象的hash值可能一样
  2. 为什么不只比较equal：因为equal可能被重写了，重写后的equal的效率要低于hash的直接比较

假设我们是第一次put，则整个for循环体都不会执行，我们继续往下看put方法。

 		modCount++;
        addEntry(hash, key, value, i);
        return null;

这里主要看addEntry方法，它应该就是把key和value封装成Entry，然后加入到table中的实现。来看看它的方法体：

void addEntry(int hash, K key, V value, int bucketIndex) {
        // 当前HashMap存储元素的个数大于HashMap扩容的阀值，则进行扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        // 使用key、value创建Entry并加入到table中
        createEntry(hash, key, value, bucketIndex);
    }

这里牵涉到了HashMap的扩容，我们先不讨论扩容，后面会讲到。然后调用了createEntry方法，它的实现如下：

void createEntry(int hash, K key, V value, int bucketIndex) {
        // 取出table中下标为bucketIndex的Entry
        Entry<K,V> e = table[bucketIndex];
        // 利用key、value来构建新的Entry
        // 并且之前存放在table[bucketIndex]处的Entry作为新Entry的next
        // 把新创建的Entry放到table[bucketIndex]位置
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // HashMap当前存储的元素个数size自增
        size++;
    }

这里其实就是根据hash、key、value以及table中下标为bucketIndex的Entry去构建一个新的Entry，其中table中下标为bucketIndex的Entry作为新Entry的next，这也说明了，当hash冲突时，采用的拉链法来解决hash冲突的，并且是把新元素是插入到单边表的表头。如下所示：

在这里插入图片描述

1.5 扩容

如果当前HashMap中存储的元素个数达到扩容的阀值，且当前要存在的值在table中要存放的位置已经有存值时，怎么处理的？我们再来看看addEntry方法中的扩容相关代码：

if ((size >= threshold) && (null != table[bucketIndex])) {
  // 将table表的长度增加到之前的两倍
     resize(2 * table.length);
     // 重新计算哈希值
     hash = (null != key) ? hash(key) : 0;
     // 重新计算新增元素在扩容后的table中应该存放的index
     bucketIndex = indexFor(hash, table.length);
 }

接下来我们看看resize是如何将table增加长度的：

void resize(int newCapacity) {
     // 保存老的table和老table的长度
     Entry[] oldTable = table;
     int oldCapacity = oldTable.length;
     if (oldCapacity == MAXIMUM_CAPACITY) {
         threshold = Integer.MAX_VALUE;
         return;
     }
     // 创建一个新的table，长度为之前的两倍
     Entry[] newTable = new Entry[newCapacity];
     // hash有关
     boolean oldAltHashing = useAltHashing;
     useAltHashing |= sun.misc.VM.isBooted() &&
             (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
     // 这里进行异或运算，一般为true
     boolean rehash = oldAltHashing ^ useAltHashing;
     // 将老table的原有数据，从新存储到新table中
     transfer(newTable, rehash);
     // 使用新table
     table = newTable;
     // 扩容后的HashMap的扩容阀门值
     threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
 }

再来看看transfer方法是如何将把老table的数据，转到扩容后的table中的：

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        // 遍历老的table数组
        for (Entry<K,V> e : table) {
            // 遍历老table数组中存储每条单项链表
            while(null != e) {
                // 取出老table中每个Entry
                Entry<K,V> next = e.next;
                if (rehash) {
                    //重新计算hash
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                // 根据hash值，算出老table中的Entry应该在新table中存储的index
                int i = indexFor(e.hash, newCapacity);
                // 让老table转移的Entry的next指向新table中它应该存储的位置
                // 即插入到了新table中index处单链表的表头
                e.next = newTable[i];
                // 将老table取出的entry，放入到新table中
                newTable[i] = e;
                // 继续取老talbe的下一个Entry
                e = next;
            }
        }
    }

从上面易知，扩容就是先创建一个长度为原来2倍的新table，然后通过遍历的方式，将老table的数据，重新计算hash并存储到新table的适当位置，最后使用新的table，并重新计算HashMap的扩容阀值。

1.6 get方法

public V get(Object key) {
  // 当key为null, 这里不讨论，后面统一讲
    if (key == null)
        return getForNullKey();
    // 根据key得到key对应的Entry
    Entry<K,V> entry = getEntry(key);
    // 
    return null == entry ? null : entry.getValue();
}

然后我们看看getEntry是如果通过key取到Entry的：

final Entry<K,V> getEntry(Object key) {
 // 根据key算出hash
    int hash = (key == null) ? 0 : hash(key);
    // 先算出hash在table中存储的index，然后遍历table中下标为index的单向链表
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        // 如果hash和key都相同，则把Entry返回
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

取值，最简单粗暴的方式肯定是遍历table，并且遍历table中存放的单向链表，这样的话，get的时间复杂度就是O(n的平方)，但是HashMap的put本身就是有规律的存储，所以，取值时，可以按照规律去降低时间复杂度。上面的代码比较简单，其实节约的就是遍历table的过程，因为我们可以用key的hash值算出key对应的Entry所在链表在在table的下标。这样，我们只要遍历单向链表就可以了，时间复杂度降低到O(n)。
get方法的取值过程如下图所示：
在这里插入图片描述

1.7 使用entrySet取数据

HashMap除了提供get方法，通过key来取数据的方式，还提供了entrySet方法来遍历HashMap的方式取数据。如下：

Map<String, String> hashMap = new HashMap<String, String>();
    hashMap.put("name1", "josan1");
    hashMap.put("name2", "josan2");
    hashMap.put("name3", "josan3");
    Set<Entry<String, String>> set = hashMap.entrySet();
    Iterator<Entry<String, String>> iterator = set.iterator();
    while(iterator.hasNext()) {
        Entry entry = iterator.next();
        String key = (String) entry.getKey();
        String value = (String) entry.getValue();
        System.out.println("key:" + key + ",value:" + value);
    }

在这里插入图片描述

结果可知，HashMap存储数据是无序的。
PS:查看更多遍历Map方法
https://blog.csdn.net/weixin_43691098/article/details/99959198

我们这里主要是讨论，它是如何来完成遍历的。HashMap重写了entrySet。

public Set<Map.Entry<K,V>> entrySet() {
        return entrySet0();
    }

    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        // 相当于返回了new EntrySet
        return es != null ? es : (entrySet = new EntrySet());
    }

代码比较简单，直接new EntrySet对象并返回，EntrySet是HashMap的内部类，注意，不是静态内部类，所以它的对象会默认持有外部类HashMap的对象，定义如下：

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
// 重写了iterator方法
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
   // 不相关代码
   ...
}

我们主要是关心iterator方法，EntrySet 重写了该方法，所以调用Set的iterator方法，会调用到这个重写的方法，方法内部很简单单，直接调用了newEntryIterator方法，返回了一个自定义的迭代器。我们看看newEntryIterator：

Iterator<Map.Entry<K,V>> newEntryIterator()   {
	return new EntryIterator();
}

可看到，直接new了一个EntryIterator对象返回，看看EntryIterator的定义：

private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
	// 重写了next方法
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}

EntryIterator 是继承了HashIterator，我们再来看看HashIterator的定义：

private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // 下一个要返回的Entry
        int expectedModCount;   // For fast-fail
        int index;              // 当前table上下标
        Entry<K,V> current;     // 当前的Entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
        // 不相关
        ......
    }

我们先看构造方法：

HashIterator() {
 expectedModCount = modCount;
    if (size > 0) { // advance to first entry
        Entry[] t = table;
        // 这里其实就是遍历table，找到第一个返回的Entry next
        // 该值是table数组的第一个有值的Entry，所以也肯定是单向链表的表头
        while (index < t.length && (next = t[index++]) == null)
            ;
    }
}

以上，就是我们调用了Iterator<Entry<String, String>> iterator = set.iterator();代码所执行的过程。

接下来就是使用while(iterator.hasNext())去循环判断是否有下一个Entry，EntryIterator没有实现hasNext方法，所以也是调用的HashIterator中的hasNext，我们来看看该方法：

public final boolean hasNext() {
// 如果下一个返回的Entry不为null，则返回true
     return next != null;
}

该方法很简单，就是判断下一个要返回的Entry next是否为null，如果HashMap中有元素，那么第一次调用hasNext时next肯定不为null，且是table数组的第一个有值的Entry，也就是第一条单向链表的表头Entry。

接下来，就到了调用EntryIterator.next去取下一个Entry了，EntryIterator对next方法进行了重写，看看该方法：

public Map.Entry<K,V> next() {
 	return nextEntry();
}

直接调用了nextEntry方法，返回下一个Entry，但是EntryIterator并没有重写nextEntry，所以还是调用的HashIterator的nextEntry方法，方法如下：

final Entry<K,V> nextEntry() {
            // 保存下一个需要返回的Entry，作为返回结果
            Entry<K,V> e = next;
            // 如果遍历到table上单向链表的最后一个元素时
            if ((next = e.next) == null) {
                Entry[] t = table;
                // 继续往下寻找table上有元素的下标
                // 并且把下一个talbe上有单向链表的表头，作为下一个返回的Entry next
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

其实nextEntry的主要作用有两点

  1. 把当前遍历到的Entry返回
  2. 准备好下一个需要返回的Entry

如果当前返回的Entry不是单向链表的最后一个元素，那只要让下一个返回的Entrynext为当前Entry的next属性（下图红色过程）；如果当前返回的Entry是单向链表的最后一个元素，那么它就没有next属性了，所以要寻找下一个table上有单向链表的表头（下图绿色过程）
在这里插入图片描述
可知，HashMap的遍历，是先遍历table，然后再遍历table上每一条单向链表，如上述的HashMap遍历出来的顺序就是Entry1、Entry2....Entry6，但显然，这不是插入的顺序，所以说：HashMap是无序的。

1.8 对key为null的处理

先看put方法时，key为null

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
       //其他不相关代码
       .......
    }

看看putForNullKey的处理

private V putForNullKey(V value) {
        // 遍历table[0]上的单向链表
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            // 如果有key为null的Entry，则替换该Entry中的value
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        // 如果没有key为null的Entry，则构造一个hash为0、key为null、value为真实值的Entry
        // 插入到table[0]上单向链表的头部
        addEntry(0, null, value, 0);
        return null;
    }

其实key为null的put过程，跟普通key值的put过程很类似，区别在于key为null的hash为0，存放在table[0]的单向链表上而已。

我们再来看看对于key为null的取值：

public V get(Object key) {
        if (key == null)
            return getForNullKey();
            //不相关的代码
            ......
    }

取值就是通过getForNullKey方法来完成的，代码如下：

private V getForNullKey() {
        //  遍历table[0]上的单向链表
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            // 如果key为null，则返回该Entry的value值
            if (e.key == null)
                return e.value;
        }
        return null;
    }

key为null的取值，跟普通key的取值也很类似，只是不需要去算hash和确定存储在table上的index而已，而是直接遍历talbe[0]。

所以，在HashMap中，不允许key重复，而key为null的情况，只允许一个key为null的Entry，并且存储在table[0]的单向链表上。

1.9 remove方法

HashMap提供了remove方法，用于根据key移除HashMap中对应的Entry

public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

首先调用removeEntryForKey方法把key对应的Entry从HashMap中移除。然后把移除的值返回。我们继续看removeEntryForKey方法：

final Entry<K,V> removeEntryForKey(Object key) {
        // 算出hash
        int hash = (key == null) ? 0 : hash(key);
        // 得到在table中的index
        int i = indexFor(hash, table.length);
        // 当前结点的上一个结点，初始为table[index]上单向链表的头结点
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            // 得到下一个结点
            Entry<K,V> next = e.next;
            Object k;
            // 如果找到了删除的结点
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                // 如果是table上的单向链表的头结点，则直接让把该结点的next结点放到头结点
                if (prev == e)
                    table[i] = next;
                else
                    // 如果不是单向链表的头结点，则把上一个结点的next指向本结点的next
                    prev.next = next;  
                // 空实现
                e.recordRemoval(this);
                return e;
            }
            // 没有找到删除的结点，继续往下找
            prev = e;
            e = next;
        }

        return e;
    }

其实逻辑也很简单，先根据key算出hash，然后根据hash得到在table上的index，再遍历talbe[index]的单向链表，这时候需要看要删除的元素是否就是单向链表的表头，如果是，则直接让table[index]=next，即删除了需要删除的元素；如果不是单向链表的头，那表示有前面的结点，则让pre.next = next，也删除了需要删除的元素。

1.10 线程安全问题

由前面HashMap的put和get方法分析可得，put和get方法真实操作的都是Entry[] table这个数组，而所有操作都没有进行同步处理，所以HashMap是线程不安全的。如果想要实现线程安全，推荐使用ConcurrentHashMap。

2.总结

  1. HashMap是基于哈希表实现的，用Entry[]来存储数据，而Entry中封装了key、value、hash以及Entry类型的next
  2. HashMap存储数据是无序的
  3. hash冲突是通过拉链法解决的
  4. HashMap的容量永远为2的幂次方，有利于哈希表的散列
  5. HashMap不支持存储多个相同的key，且只保存一个key为null的值，多个会覆盖
  6. put过程，是先通过key算出hash，然后用hash算出应该存储在table中的index，然后遍历table[index]，看是否有相同的key存在，存在，则更新value；不存在则插入到table[index]单向链表的表头，时间复杂度为O(n)
  7. get过程，通过key算出hash，然后用hash算出应该存储在table中的index，然后遍历table[index]，然后比对key，找到相同的key，则取出其value，时间复杂度为O(n)
  8. HashMap是线程不安全的，如果有线程安全需求，推荐使用ConcurrentHashMap。

3.Hash冲突

当遇到hash冲突时，HashMap本身是怎么解决的？
通过以上我们知道Entry的存储过程步骤为：

  1. 通过hashcode()方法计算哈希值
  2. 利用哈希值为table.length取模，即indexFor()方法决定放在数组的哪个位置

思考：如果当不同key计算得到哈希值一样时，通过indexFor计算后table[index]也就相同
，这时HashMap本身会做如下图操作：
在这里插入图片描述
当发生hash冲突时，则将存放在数组中的Entry设置为新值的next（这里要注意的是，比如A和B都hash后都映射到下标i中，之前已经有A了，当map.put(B)时，将B放到下标i中，A则为B的next，所以新值存放在数组中，旧值在新值的链表上）

所以当hash冲突很多时，HashMap退化成链表。

张运营
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java容器之ConcurrentHashMap源码分析（JDK 1.7与JDK 1.8对比）
hestyle的博客
04-14 506
  在前面两篇博客 Java容器之HashMap源码分析、Java容器之Hashtable源码分析分别对JDK1.8中的HashMap、Hashtable的源码进行一些分析，在本篇博客将对ConcurrentHashMap容器的源码进行一些分析。 申明：在前两篇博客介绍了两个容器的增、删、改、查相关的API，并且给源码加上了中文注释，在本篇博客将只介绍一些关键的API，比如hash值的计算，put...
《Java源码分析》：ConcurrentHashMap JDK1.8
热门推荐
wojiushimogui的博客
08-07 1万+
《Java源码分析》：ConcurrentHashMap JDK1.8最近一直在看关于J.U.C中的源码，了解原子操作，了解锁机制，了解多线程并发等等。但是ConcurrentHashMap一直拖着到今天才算告一段落。也要感谢ConcurrentHashMap这个类，刚开始就是想弄懂里面的工作原理，但是，无奈看了网上关于介绍ConcurrentHashMap这个类的资料或博客都是基于JDK1.8以
HashMap 底层实现原理 JDK1.7
爱喝咖啡的程序员的博客
03-22 813
一. 数据结构 hash
Java ConcurrentHashMap底层实现原理（JDK1.7&1.8）【源码分析】
单枪匹码
09-27 972
我们都知道HashMap在多线程情况下，在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致get时会出现死循环，所以HashMap是线程不安全的。 我们来了解另一个键值存储集合HashTable，它是线程安全的，它在所有涉及到多线程操作的都加上了synchronized关键字来锁住整个
JDK1.7的HashMap的put(key, value)源码剖析
weixin_30888027的博客
11-10 217
目录 HashMap的put操作源码解析 1、官方文档 2、put(key, value) 3、完结 HashMap的put操作源码解析 1、官方文档 1.1、继承结构 java.lang.Object java.util.Abstra...
HashMap和CurrentHashMap的源码解析
qq_24045275的博客
03-15 505
HashMap Java 7 1、首先我们查看hashMap底层是由什么组成的 先写一个代码了进入源码 HashMap<String, String> map = new HashMap<>(); map.put(“James”, “James is handsome”); 进入到put中可以查看到其源码： public V put(K key, V value) {...
Java中HashMap底层源码分析(JDK1.7)
Obscurede的博客
08-12 366
JavaHashMap底层源码的分析(JDK1.7)
HashMap源码(JDK1.7,含注释)
06-02
HashMap源码(JDK1.7,含注释)
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
javahashmap源码-java_HashMap_jdk1.7:我的hashmap
05-24
在JDK 1.7版本中，HashMap的实现机制有着独特的设计，本文将详细剖析其内部的工作原理和源码实现。 1. **HashMap的基本结构** HashMap基于哈希表（散列表）的数据结构，内部使用一个Entry数组作为主要的数据存储...
jdk1.7源码
02-01
此外，JDK 1.7源码还包含了大量的标准库，如`java.lang`, `java.util`, `java.io`等，这些都是Java开发的基础。通过阅读这些类的源码，可以学习到各种设计模式，如工厂模式、单例模式、装饰器模式等，同时也能理解...
jdk1.7源码包含util
01-30
在JDK 1.7版本中，"util"指的是`java.util`包，它是Java标准库中的核心部分，提供了大量用于日常编程的工具类和接口。这个包的源码对于理解Java内部机制和提高编程技能至关重要。 `java.util`包包含了多种数据结构...
HashMap源码解析
Jasonzhou
05-24 266
一、前言 HashMap这个数据结构，不管是在实际应用中还是面试中，都是很重要的知识点。例如：在实际应用中，我们需要在O(1)时间内查找到相关的元素，假如遍历数据找其相关元素，那时间复杂度就是O(n)了，不符合我们需要在O(1)时间复杂度里找到其元素，这时我们就想到用ＨashMap这个数据结构来进行查找，通过匹配key和value值，可以在O(1)时间内快速找到。再比如，在面试中，面试官对HashMap底层原理会进行全方位的考察，如：HashMap 1.7，1.8底层原理有什么区别？扩容机制？线程是否安全？
java基础之HashMap（jdk1.7）中的put()操作，源码分析
醒醒
04-30 722
1.HashMap允许key和value都为空，HashMap是线程不安全的。HashTable中的key和value都不能为空。HashTable是线程安全的。 2.HashMap中桶的概念：在jdk1.7中，HashMap是由数组和链表组成的。数组的每个索引被称作桶。 3.为什么在jdk1.7中，HashMap是由数组和链表组成的？ ...
CurrentHashMap源码分析
Munger6的博客
08-14 985
1、ConcurrentHashmap的由来 HashMap不是线程安全的，在多线程情况下会导致扩容出现循环链表，造成访问这个Entry的线程死循环，CPU接近100%； Hashtable，使用synchronized进行线程安全的控制，因为每次只有一个对象获取监视器锁，因此在高并发情况下，性能再次成为瓶颈。类似表锁； Concurren...
jdk1.7里面的hashmap
dongbeihuxiao的博客
09-05 397
hashmap的底层是由数组和链表实现的，数组大小如果不设置的话默认长度为16。 根据key的值以及其他的一些参数，比如hashSeed来计算出一个hash，然后通过hash和数组长度计算出一个下标。
Java 1.7 HashMap源码阅读
yelongshang1的博客
04-06 153
1. 构造函数 2.PUT方法 3.resize扩容 4.remove 5 hash 6.多线程不安全演示
JAVA基础 - hashMap(JDK1.7)
记录自己
11-17 232
这些问题你都知道了吗？ hashMap 存储的和遍历 出来的 值 顺序是否一致？ key == null 怎么存储。 每次容量增大多少 加载因子 hashCode 数据分布 随机性 并发问题 死链问题 数据丢失问题 定义的常亮或变量 /** * The default initial capacity - MUST be a power of two. * 必...
Java文件路径中的/与\\
weixin_43691098的博客
04-13 2316
对于文件路径中/和\，我感觉每个都在代码中见过，觉得有些奇怪，于是查了一下资料，做一下整理： 一般可以认为是"/“的作用等同于”\" 在Java中路径一般用"/" windows中的路径一般用"" linux、unix中的路径一般用"/" 所以在java中写windows路径一般用"/“或将”“转义一下，就成了”\" 最好用“/”，因为java是跨平台的 “\”（在java代码里应该是\）是win...
hashMap的数据结构jdk1.7和1.8的区别 java
最新发布
04-04
在JDK1.7中，hashMap的实现是基于数组和链表的结构，称为链表散列。当元素被添加到hashMap中时，它首先被分配到一个桶中，桶是一个数组，然后该元素被添加到该桶的链表中。如果有多个元素被分配到同一个桶中，则它们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值