JAVA架构之路（三）

HashMap的源码赏析。

HashMap是Java中的一种数据结构，它实现了Map接口，用于存储键值对映射关系。HashMap是非线程安全的，它允许使用null键和null值。

HashMap的工作原理是基于哈希表实现的，通过哈希函数将键转化为数组的索引来存储和访问数据。HashMap使用散列算法将键映射到桶中，每个桶中存储着键值对。

HashMap具有以下特性：

1. 无序性：HashMap中的元素没有顺序，每次遍历的结果可能不同。
2. 允许null键和null值：HashMap允许使用null键和null值，但只能有一个null键和一个null值。
3. 非线程安全：HashMap是非线程安全的，如果多个线程同时修改HashMap，可能会导致数据不一致。
4. 存储空间：HashMap使用哈希表来存储数据，需要额外的存储空间来记录键值对与桶的映射关系。

使用HashMap时需要注意以下几点：

1. 在遍历HashMap时，如果需要修改HashMap（例如添加、删除元素），则必须使用迭代器（Iterator）的remove()方法来删除元素，否则会抛出ConcurrentModificationException异常。
2. 如果需要多个线程同时读写HashMap，可以使用Collections.synchronizedMap()方法将HashMap转换成线程安全的版本。
3. 在处理大数据量时，需要注意HashMap的容量和加载因子（load factor），如果加载因子设置得太高，可能会导致哈希冲突增加，影响性能。如果设置得太低，可能会导致空间浪费过多。

HashMap的实现原来是单向链表加数组的实现。

核心代码

我们看到的put方法：

实现细节：

我们看get方法：

 源码：

/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
 
package java.util;
 
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
 
/**
 * Hash table based implementation of the Map interface.  This
 * implementation provides all of the optional map operations, and permits
 * null values and the null key.  (The HashMap
 * class is roughly equivalent to Hashtable, except that it is
 * unsynchronized and permits nulls.)  This class makes no guarantees as to
 * the order of the map; in particular, it does not guarantee that the order
 * will remain constant over time.
 *
 * 
This implementation provides constant-time performance for the basic
 * operations (get and put), assuming the hash function
 * disperses the elements properly among the buckets.  Iteration over
 * collection views requires time proportional to the "capacity" of the
 * HashMap instance (the number of buckets) plus its size (the number
 * of key-value mappings).  Thus, it's very important not to set the initial
 * capacity too high (or the load factor too low) if iteration performance is
 * important.
 *
 * 
An instance of HashMap has two parameters that affect its
 * performance: initial capacity and load factor.  The
 * capacity is the number of buckets in the hash table, and the initial
 * capacity is simply the capacity at the time the hash table is created.  The
 * load factor is a measure of how full the hash table is allowed to
 * get before its capacity is automatically increased.  When the number of
 * entries in the hash table exceeds the product of the load factor and the
 * current capacity, the hash table is rehashed (that is, internal data
 * structures are rebuilt) so that the hash table has approximately twice the
 * number of buckets.
 *
 * 
As a general rule, the default load factor (.75) offers a good
 * tradeoff between time and space costs.  Higher values decrease the
 * space overhead but increase the lookup cost (reflected in most of
 * the operations of the HashMap class, including
 * get and put).  The expected number of entries in
 * the map and its load factor should be taken into account when
 * setting its initial capacity, so as to minimize the number of
 * rehash operations.  If the initial capacity is greater than the
 * maximum number of entries divided by the load factor, no rehash
 * operations will ever occur.
 *
 * 
If many mappings are to be stored in a HashMap
 * instance, creating it with a sufficiently large capacity will allow
 * the mappings to be stored more efficiently than letting it perform
 * automatic rehashing as needed to grow the table.  Note that using
 * many keys with the same {@code hashCode()} is a sure way to slow
 * down performance of any hash table. To ameliorate impact, when keys
 * are {@link Comparable}, this class may use comparison order among
 * keys to help break ties.
 *
 * 
Note that this implementation is not synchronized.
 * If multiple threads access a hash map concurrently, and at least one of
 * the threads modifies the map structurally, it must be
 * synchronized externally.  (A structural modification is any operation
 * that adds or deletes one or more mappings; merely changing the value
 * associated with a key that an instance already contains is not a
 * structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the map.
 *
 * If no such object exists, the map should be "wrapped" using the
 * {@link Collections#synchronizedMap Collections.synchronizedMap}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the map:
 *   Map m = Collections.synchronizedMap(new HashMap(...));