Java 集合源码分析

集合简介
迭代器
- Iterable接口
- Iterator 接口
Collection接口
List体系
- 体系结构
- List接口
- ArrayList源码解析
Map体系
- 体系结构
- Map接口
- HashMap源码分析
- HashMap的常见问题
- hashCode()、equals()
Set体系
- 体系结构
- 常见实现类
集合遍历
集合工具类 Collections
array、list、set 的相互转换
使用集合的注意点

jdk源码版本1.8。

体系结构图只列出了常见的接口、类，白色的是接口，黄色的类（包括抽象类）。

集合简介

集合用于存储指定类型的元素，部分集合还实现了栈、队列、树等数据结构。

集合的两个根接口

Collection 单列集合
Map 双列集合

/*** 存储map中所有的key*/
Set<K> keySet();/*** 存储map中所有的value*/
Collection<V> values();

Map内置了2个单例集合分别存储key、value，key唯一标识一个键值对，使用Set存储，不可重复。

集合的实现类都重写了toString()方法。

迭代器

Iterable接口

iterable 可迭代的，继承了此接口的接口、类都具有可迭代的能力

public interface Iterable<T> {/*** 获取迭代器*/Iterator<T> iterator();default void forEach(Consumer<? super T> action) {Objects.requireNonNull(action);for (T t : this) {action.accept(t);}}default Spliterator<T> spliterator() {return Spliterators.spliteratorUnknownSize(iterator(), 0);}
}

Iterable接口提供了3个方法，对应3种迭代方式

iterator 迭代器
forEach循环
spliterator()，这个是流式操作中的方法

Iterator 接口

iterator 迭代器，可通过迭代器迭代元素

public interface Iterator<E> {/*** 是否还有下一个元素*/boolean hasNext();/*** 返回下一个元素*/E next();/*** 删除底层集合中上一次next()返回的元素。注意：* 1、在迭代过程中，不能使用集合自身的方法删除元素，只能使用迭代的remove()方法删除元素* 2、每次调用next时最多可以调用remove()一次*/default void remove() {throw new UnsupportedOperationException("remove");}/*** 对每个剩余元素进行相同操作*/default void forEachRemaining(Consumer<? super E> action) {Objects.requireNonNull(action);while (hasNext())action.accept(next());}
}

Iterator 接口在获取迭代器后，提供了2种迭代方式

while循环 + hasNext() + next()
forEachRemaining()

此外还提供了在迭代中删除底层集合元素的 remove() 方法。

jdk提供了 fail-fast 机制，如果在遍历集合时，其它线程修改了正在遍历的集合，会快速失败，抛出异常。

如果要保证集合的线程安全，尽量使用juc中线程安全的集合。

Collection接口

这篇博文中涉及到的Collection、List、Set、Map接口，都可以仔细看下，学习一下如何设计接口。

相关问题：让你设计一个 list | set | map | 集合，你会怎么设计

public interface Collection<E> extends Iterable<E> {//整体操作/*** 获取集合中的元素数量*/int size();/*** 判断集合是否为空（集合中是否有元素）*/boolean isEmpty();/*** 判断集合中是否包含指定元素*/boolean contains(Object o);/*** 获取对应的迭代器*/Iterator<E> iterator();/*** 集合转Object数组*/Object[] toArray();/*** 集合转指定类型的数组*/<T> T[] toArray(T[] a);//单个元素的操作/*** 添加元素，true表示添加成功*/boolean add(E e);/*** 移除元素，true表示移除成功*/boolean remove(Object o);//批量操作//以下方法是同时操作多个元素的（批量操作）/*** 是否包含指定集合中的全部元素*/boolean containsAll(Collection<?> c);boolean addAll(Collection<? extends E> c);boolean removeAll(Collection<?> c);/*** 移除满足要求的所有元素，要求由函数式接口 Predicate 指定*/default boolean removeIf(Predicate<? super E> filter) {Objects.requireNonNull(filter);boolean removed = false;final Iterator<E> each = iterator();while (each.hasNext()) {if (filter.test(each.next())) {each.remove();removed = true;}}return removed;}/*** 只保留指定集合中的元素，会移除其它所有元素*/boolean retainAll(Collection<?> c);/*** 移除所有元素，清空集合*/void clear();//集合自身的equals()、hashCode()方法，用于判断当前集合对象与指定对象是否相等boolean equals(Object o);int hashCode();//以下3个是流式操作的方法@Overridedefault Spliterator<E> spliterator() {return Spliterators.spliterator(this, 0);}default Stream<E> stream() {return StreamSupport.stream(spliterator(), false);}default Stream<E> parallelStream() {return StreamSupport.stream(spliterator(), true);}
}

Collection接口主要做了2件事

继承了 Iterable 接口，具有迭代能力。Map中存储key、value的2个集合也是Collection体系的，也具有迭代能力。
定义了操作集合本身、单个元素、批量操作、流式操作的一些通用方法。

List体系

体系结构

List 元素有序、可重复，有序是指元素有对应的下标，可通过下标检索元素，元素可重复是建立在元素有序的基础上的。

List的实现类众多，图中只列出了常见的，添加元素时List的常见实现类都可以添加值为null的元素，如果某些实现类不允许添加值为null的元素，则add(null)会抛出空指针异常。

RandomAccess只是一个标记接口，标示具有随机访问能力，一般都是使用内置数组来实现随机访问。

实现 Cloneable 接口，是为了使用根类Object的clone()拷贝集合，但这只是一种浅拷贝。

ArrayList、Vector、Stack

ArrayList、Vector都是基于数组实现的，内置了一个数组，添加元素时如果数组容量不足都会动态扩容。
Vector有一个子类Stack，用于实现栈，Vector、Stack中的很多方法都使用 synchronized 修饰，线程安全，ArrayList则不是线程安全的。

如果不需要保证线程安全，尽量用ArrayList代替Vector；需要要保证线程安全，尽量用juc下的类代替Vector。

LinkedList

LinkedList是基于双向链表实现的list，本身还可以作为（双端）队列使用。
链表本身是按添加顺序进行存储，但不具有下标，所以使用了 AbstractSequentialList 来增加下标操作。AbstractSequentialList 相当于适配器，在链表的基础上增加下标操作。

ArrayList、Vector、LinkedList的比较

ArrayList、Vector基于数组，随机存取，查找元素速度快，但增删元素时要移动大量元素，速度慢，适合以读为主、增删不频繁的场景；LinkedList基于双向链表，查找元素要遍历链表，速度慢，但增删元素只需修改引用，速度快，适合增删元素频繁的场景。
空间利用率 ArrayList、Vector 不如 LinkedList，但这2个类都提供了 trimToSize() 方法用于修剪集合，用容量正合适的数组来存储元素。
ArrayList、LinkedList不是线程安全的，Vector线程安全。维护线程安全有额外开销，且Vector缺点很多，一般不用，如果不要求线程安全，尽量用 ArrayList 代替 Vector。

List接口

public interface List<E> extends Collection<E> {// Query Operationsint size();boolean isEmpty();boolean contains(Object o);Iterator<E> iterator();Object[] toArray();<T> T[] toArray(T[] a);// Modification Operationsboolean add(E e);boolean remove(Object o);// Bulk Modification Operationsboolean containsAll(Collection<?> c);boolean addAll(Collection<? extends E> c);boolean addAll(int index, Collection<? extends E> c);boolean removeAll(Collection<?> c);boolean retainAll(Collection<?> c);default void replaceAll(UnaryOperator<E> operator) {Objects.requireNonNull(operator);final ListIterator<E> li = this.listIterator();while (li.hasNext()) {li.set(operator.apply(li.next()));}}@SuppressWarnings({"unchecked", "rawtypes"})default void sort(Comparator<? super E> c) {Object[] a = this.toArray();Arrays.sort(a, (Comparator) c);ListIterator<E> i = this.listIterator();for (Object e : a) {i.next();i.set((E) e);}}void clear();// Comparison and hashingboolean equals(Object o);int hashCode();// Positional Access OperationsE get(int index);E set(int index, E element);void add(int index, E element);E remove(int index);// Search Operationsint indexOf(Object o);int lastIndexOf(Object o);// List IteratorsListIterator<E> listIterator();ListIterator<E> listIterator(int index);// ViewList<E> subList(int fromIndex, int toIndex);@Overridedefault Spliterator<E> spliterator() {return Spliterators.spliterator(this, Spliterator.ORDERED);}
}

List中的元素有序（可通过下标操作），List接口定义了常用的下标操作，比如

add()、remove()、set() 在指定位置上添加|删除|更新元素
indexOf() 获取指定元素对应的下标
subList() 获取指定区间上的子集合

ArrayList源码解析

ArrayList的部分源码

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{/*** 默认容量 10，容量指的是数组长度*/private static final int DEFAULT_CAPACITY = 10;/*** 空数组*/private static final Object[] EMPTY_ELEMENTDATA = {};/*** 默认容量的空数组*/private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};/*** 内置数组，不可序列化*/transient Object[] elementData;/*** 存储的元素个数*/private int size;/*** 带参的构造方法，指定初始容量* 指定的容量大于0，则使用指定的初始容量；等于0则初始化为空数组；小于0则抛出异常*/public ArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}/*** 无参的构造方法，初始化为空数组，注意并没有使用默认容量*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}/*** 从现有集合构建。如果指定集合中没有元素，则初始化为一个空数组*/public ArrayList(Collection<? extends E> c) {Object[] a = c.toArray();if ((size = a.length) != 0) {if (c.getClass() == ArrayList.class) {elementData = a;} else {elementData = Arrays.copyOf(a, size, Object[].class);}} else {//初始化为空数组elementData = EMPTY_ELEMENTDATA;}}/*** 修剪集合，如果数组容量多余，则将元素移到容量正合适的数组中存储*/public synchronized void trimToSize() {modCount++;int oldCapacity = elementData.length;if (elementCount < oldCapacity) {elementData = Arrays.copyOf(elementData, elementCount);}}/*** 在列表末尾添加元素*/public boolean add(E e) {//确保容量足够，不够会自动扩容ensureCapacityInternal(size + 1);//将元素个数+1，添加到数组已存储元素的后面elementData[size++] = e;return true;}/*** 在指定位置添加元素*/public void add(int index, E element) {//检查下标是否合法，不合法则抛出异常。合法范围 [0,size]rangeCheckForAdd(index);//确保容量足够，不够会自动扩容ensureCapacityInternal(size + 1);  // Increments modCount!!//将指定位置的后续元素全部后移一位//采用的是数组复制，源数组、目标数组相同，只是对应区间向后移一位System.arraycopy(elementData, index, elementData, index + 1, size - index);//给数组的指定位置赋值elementData[index] = element;//将存储的元素个数+1size++;}//...}

Arrays.copyOf()、System.arraycopy() 都可以复制数组元素

ArrayList的扩容机制

/*** 内置数组的最大容量* 部分JVM在数组中存储一些头部字段（header words），所以预留了少数空间，没取MAX_VALUE，防止 OutOfMemoryError*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;/*** 记录内置数组的容量修改次数，扩容、缩容都会记录*/
protected transient int modCount = 0;//确保容量的入口函数，实参是所需容量，即当前存储的元素个数+要添加的元素个数
private void ensureCapacityInternal(int minCapacity) {//先调calculateCapacity()，再调 ensureExplicitCapacity()ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}private static int calculateCapacity(Object[] elementData, int minCapacity) {// 如果创建ArrayList时没有指定初始容量，第一次添加元素时会取默认容量、所需容量中的较大者作为所需容量// DEFAULTCAPACITY_EMPTY_ELEMENTDATA、EMPTY_ELEMENTDATA 都是空数组，但标识的初始状态不同// 使用无参构造方法不指定初始容量时初始化为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，显式指定了初始容量为0时初始化为 EMPTY_ELEMENTDATA// 开发显式指定了初始容量为0，说明人家就是需要这个容量值，此时没必要使用默认容量if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);}//如果创建ArrayList时显式指定了初始容量，则直接取所需容量return minCapacity;
}private void ensureExplicitCapacity(int minCapacity) {//容量改变次数+1modCount++;//如果目标容量大于当前容量，则调用 grow() 进行扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}//扩容
private void grow(int minCapacity) {int oldCapacity = elementData.length;//新容量为原来的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1);//如果新容量小于所需容器，则取所需容量if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//如果新容量大于容量上限，则取 Integer.MAX_VALUEif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//扩容，复制元素到新数组elementData = Arrays.copyOf(elementData, newCapacity);
}//在目标容量超过容量上限时，取 Integer.MAX_VALUE
private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

计算过程如下

如果创建 ArrayList 时没有显式指定初始容量，则第一次添加元素时会取默认容量、所需容量中的较大者作为所需容量；
如果所需容量大于原容量的1.5倍，则取所需容量，否则取原容量的1.5倍
如果目标容量大于容量上限（ Integer.MAX_VALUE - 8 ），则取 Integer.MAX_VALUE

ensureCapacity() 手动扩容
ArrayList、Vector这些基于数组的list都提供了手动扩容的 ensureCapacity() 方法，上面的几个扩容相关的方法都是private，这个是public，暴露出来的手动扩容方法。

如果即将要向ArrayList、Vector、Stack中添加大量元素，可以先调用 ensureCapacity() 一次性扩容，以减少自动扩容次数，提高性能

//参数是所需容量
//这个方法在所需容量大于原容量时才会扩容，即只能扩容，不能缩容
ensureCapacity(int minCapacity)

Map体系

体系结构

HashMap：使用哈希表存储元素，使用的哈希值是key的
LinkedHashMap：在哈希表的基础上，增加了一个双向链表维护元素的添加顺序。元素的增改删查都是通过哈希表进行，效率高，更新哈希表时会同步更新到链表，链表只用于遍历。
SortedMap：元素按指定的顺序进行存储。Sorted 有序，指的是存储有序，并没有关联下标。可以用函数式接口 Comparator 指定排序规则。
NavigableMap：可导航的map，可导航指的是提供了一些方法，可以获取key大于、小于指定值的所有键值对，可以获取开头、末尾部分的键值对，可以获取首、尾键值对，可以获取指定区间上的所有键值对。
TreeMap：使用红黑树存储元素。可以构造方法中用 Comparator 接口指定排序规则，未指定时默认使用自然排序。
Hashtable：t是小写，和HashMap一样都是使用哈希表存储元素，但Hashtable线程安全，只是缺点较多，很少使用。
Properties：主要用于加载、解析properties文件
EnumMap：以枚举类的实例作为key

TreeMap可指定排序方式，LinkedHashMap使用双向链表维护添加顺序，TreeMap、LinkedHashMap在某种程度上也可以认为是有序的，只不过不是 list 这种元素关联下标的有序。

性能比较

TreeMap：内部要维护红黑树，增删元素性能差
Hashtable：要保证线程安全，有额外开销，性能差
LinkedHashMap：在HashMap的基础上要维护一个双向链表，增删性能比HashMap稍微差一些，但正由于双向链表，遍历时速度往往比HashMap快。
HashMap：元素的增删查改性能都不错，遍历时需要先过滤掉哈希表中的空桶，速度往往比LinkedHashMap慢。

关于Dictionary

public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, java.io.Serializable

Hashtable在继承Dictionary的同时实现了Map，Dictionary、Map基本是一样的，包含了大量的相同方法

NOTE: This class is obsolete. New implementations should implement the Map interface, rather than extending this class.

官方在注释中提示，Dictionary将被废弃，使用Map代替。同时继承Dictionary、实现Map只是作为过渡，后续版本不再 extends Dictionary，直接implements Map。

HashMap、Hashtable的联系与区别

相同点：都是使用哈希表存储元素
HashMap线程不安全，Hashtable提供的方法基本都使用 synchronized 修饰，线程安全
HashMap的key、value都可以为null，Hashtable的key、value都不能为null

Hashtable缺点很多，基本不用，官方建议：如果不需要保证线程安全，尽量使用HashMap代替Hashtable；如果需要保证线程安全，尽量使用juc中的 ConcurrentHashMap 代替 Hashtable。

Map接口

public interface Map<K,V> {//对整个map的操作int size();boolean isEmpty();//对单个元素的操作boolean containsKey(Object key);boolean containsValue(Object value);V get(Object key);V put(K key, V value);V remove(Object key);//批量操作void putAll(Map<? extends K, ? extends V> m);void clear();//view，集合视图，用于迭代Set<K> keySet();Collection<V> values();Set<Map.Entry<K, V>> entrySet();//内置接口，键值对interface Entry<K,V> {K getKey();V getValue();V setValue(V value);boolean equals(Object o);int hashCode();public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {//...}public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {//...}public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {//...}public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {//...}}//equals、hashCodeboolean equals(Object o);int hashCode();//默认方法，包括 OrDefault、IfAbsent，自定义过滤条件、自定义处理方式default V getOrDefault(Object key, V defaultValue) {V v;//...}default void forEach(BiConsumer<? super K, ? super V> action) {//...}default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {//...}default V putIfAbsent(K key, V value) {//...}default boolean remove(Object key, Object value) {//...}default boolean replace(K key, V oldValue, V newValue) {//...}default V replace(K key, V value) {//...}default V computeIfAbsent(K key,Function<? super K, ? extends V> mappingFunction) {//...}default V computeIfPresent(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {//...}default V compute(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {//...}default V merge(K key, V value,BiFunction<? super V, ? super V, ? extends V> remappingFunction) {//...}}

Map使用内部接口Entry来封装键值对。

HashMap源码分析

成员变量

/**
* 默认初始容量，2^4 = 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;/*** 最大容量，2^30*/
static final int MAXIMUM_CAPACITY = 1 << 30;/*** 默认的负载因子*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;/*** 树化阈值，链表中的元素数量大于8时，链表会转换为红黑树* threshold 阈值*/
static final int TREEIFY_THRESHOLD = 8;/*** 非树化阈值，红黑树中的节点数量小于6时，红黑树会退化为链表。*/
static final int UNTREEIFY_THRESHOLD = 6;/*** 最小树化容量，bucket中的元素数量达到阈值，且哈希表的容量达到阈值（>=64），才会树化。* * 这个参数主要是为了防止：哈希表本身存储的元素数量不多，但单个bucket存储的元素数量很多时就发生树化。* 这种情况应该避免，尽量让元素直接存储在哈希表（数组）中，一个bucket存储一个元素，这样性能才高；* 大部分元素都存储到bucket中的链表上去了，性能低，不符合哈希表的设计初衷。*/
static final int MIN_TREEIFY_CAPACITY = 64;/*** 内置数组，作为哈希表，长度|容量始终为2的次方数，一个Node即一个bucket*/
transient Node<K,V>[] table;/*** 缓存的键值对*/
transient Set<Map.Entry<K,V>> entrySet;/*** 存储的元素数量，不管是直接存储在数组中，还是存储在链表、红黑树中，都算*/
transient int size;/*** 哈希表结构被修改的次数，添加、删除才算，更新已存在的元素不算*/
transient int modCount;/*** 下次重哈希的阈值。* threshold = (int) (capacity * load factor)，存储的元素数量大于此阈值时触发重哈希*/
int threshold;/*** 哈希表的负载因子*/
final float loadFactor;

静态内部类

/*** 数组元素。* 在LinkedHashMap中，静态内部类 Entry<K,V> extends HashMap.Node<K,V> 作为链表的节点*/
static class Node<K,V> implements Map.Entry<K,V> {//...
}/*** 红黑树节点。* 间接继承了上面的 Node<K,V>*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {/*** 链表树化*/final void treeify(Node<K,V>[] tab) {//...}/*** 红黑树退化为链表*/final Node<K,V> untreeify(HashMap<K,V> map) {//...}//...}

预留给 LinkedHashMap 重写的空方法

HashMap在自身的元素增删改操作中，分别调用了以下对应的方法，这些方法在HashMap中都是空实现，都是作为扩展点留给LinkedHashMap重写的。

LinkedHashMap在HashMap的基础上要维护链表，对这3个方法的重写都是更新链表，用于在更新哈希表后同步更新链表。

//更新元素（key对应的value）
void afterNodeAccess(Node<K,V> p) { }//添加元素
void afterNodeInsertion(boolean evict) { }//删除元素
void afterNodeRemoval(Node<K,V> p) { }

hash()、tableSizeFor()

/*** 根据key计算hash，在key的hashCode基础上进行了位移、异或操作。* 位移的16是综合各方面折中取的*/
static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}/*** 根据传入的容量返回合适的哈希表容量，2的次方* 哈希表容量只能为2的次方，[2^0，2^30]，转换示例：0、1 => 1   2=>2   3、4=>4   5~8 => 8*/
static final int tableSizeFor(int cap) {int n = cap - 1;n |= n >>> 1;n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

构造方法

/*** 指定初始容量、负载因子*/
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);this.loadFactor = loadFactor;//初始化重哈希阈值this.threshold = tableSizeFor(initialCapacity);
}/*** 指定初始容量*/
public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);
}/*** 无参构造器，使用默认容量（16）、默认负载因子（0.75）*/
public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR;
}/*** 从已有map构建，使用的仍是默认的负载因子*/
public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);
}

hash系列集合都可以通过构造方法指定初始容量、负载因子。

负载因子较大时，节省内存空间，但容易发生哈希冲突，元素存储效率降低；负载因子较小时，哈希冲突频率低，元素存储效率高，但存在大量空桶、浪费空间，如果不是LinkedHashMap这种有双向链表的，遍历时还需要遍历所有的桶，要判断大量的空桶，遍历速度慢。

默认的负载因子 0.75 是时间、空间的折中，一般使用默认的负载因子即可。

尽量预估元素数量，创建hash系列集合时指定初始容量，避免频繁重哈希，以提升性能，初始容量一般设置为：预估的元素数量 / 0.75，结果向上取整。

put()方法

public V put(K key, V value) {//hash是对key进行哈希计算return putVal(hash(key), key, value, false, true);
}final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {//tab是临时数组（哈希表），n是数组长度|容量，i是数组下标即要使用的数组位置，p是i位置对应的数组元素//后续会逐渐赋值Node<K,V>[] tab; Node<K,V> p; int n, i;//如果数组为空，则先 resize() 初始化数组//resize()用于扩容，如果未初始化会先初始化if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;//计算数组下标i，如果该位置尚未存储元素（ p==null ），则直接存储到该位置if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);//执行到else中，说明该位置已存在元素else {Node<K,V> e; K k;//如果和该位置已存在的元素的key、hash值都相同，则记录已存在的元素if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))e = p;//如果已存在的元素是树节点，说明使用红黑树存储元素，则添加到红黑树中//如果红黑树中存在key、hash值都相同的节点，同样是记录已存在的节点，不会再添加到树中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);//如果链表之前存储的元素个数 >=8，新添加一个后 >=9，则进行树化//即添加节点后如果链表长度 >8 就将链表转换为红黑树if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st//传入的数组、hash值 => 计算要使用的下标、确定bucket => 确定这个桶存储的链表treeifyBin(tab, hash);break;}//如果链表中已存在相同的key，且hash值相同，则退出循环、不再插入，记录已存在的元素if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}//如果数组、链表或红黑树中已存在相同的keyif (e != null) { // existing mapping for keyV oldValue = e.value;//如果onlyIfAbsent为false或原value是null，则直接覆盖原value//put()传入的onlyIfAbsent是false，条件永真，都是直接覆盖原valueif (!onlyIfAbsent || oldValue == null)e.value = value;//留给LinkedHashMap的扩展点，用于同步向双向链表中更新节点afterNodeAccess(e);//返回原valuereturn oldValue;}}//执行到此说明是新增操作，而非更新//哈希表结构修改次数+1++modCount;//存储的元素数量+1。如果存储的元素数量超过阈值，则触发重哈希，进行扩容if (++size > threshold)resize();//留给LinkedHashMap的扩展点，用于同步向双向链表中添加节点afterNodeInsertion(evict);//返回nullreturn null;
}

put()流程

对key进行hash计算，传给 putVal() 方法，后续都是 putVal() 在操作
如果数组为空，则先 resize() 初始化数组
计算数组下标（存储位置）
如果该位置尚未存储元素，则直接存储到该位置；如果该位置已经存储了红黑树或链表，则把元素添加到红黑树中或添加到链表尾部，添加到链表中后，如果链表长度大于8，会将链表转换为红黑树。如果已存在相同的key，不再进行添加，会先记录原来的元素，并替换value。
如果是添加操作，会把哈希表结构修改次数+1、已存储的元素个数+1，如果已存储的元素个数超过重哈希阈值，则进行重哈希，对数组进行扩容。
更新操作返回的是原来的value，添加操作返回的是null。

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) {//如果原容量达到容量上限，则重哈希阈值直接取 Integer.MAX_VALUE，不再进行扩容，直接返回原数组，任其发生hash冲突if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}//如果原容量大于等于默认容量，且扩容为原容量的2倍后仍小于最大容量，则将容量、重哈希阈值都扩大为原来的2倍else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)newThr = oldThr << 1;}//如果原容量为0（负数是不合法的），且原重哈希阈值大于0，则初始化容量为原重哈希阈值else if (oldThr > 0)newCap = oldThr;//否则初始化容量为默认容量（16），重哈希阈值为默认容量*默认负载因子再取整（12）else {newCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}//如果新的重哈希阈值为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"})//创建新数组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 orderNode<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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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扩容机制

如果原容量达到容量上限，则重哈希阈值直接取 Integer.MAX_VALUE，不再进行扩容，直接返回原数组，任其发生hash冲突；
如果原容量大于等于默认容量，且扩容为原容量的2倍后仍小于最大容量，则将容量、重哈希阈值都扩大为原来的2倍；
如果原容量为0（负数不合法），且原重哈希阈值大于0，则初始化容量为原重哈希阈值；
否则（原容量、原重哈希阈值都为0），初始化容量为默认容量（16），重哈希阈值为默认容量*默认负载因子再取整（12）。

如果新的重哈希阈值为0，则以单精度浮点数的方式重新计算重哈希阈值。
创建新数组，重新计算存储位置，将原数组各个bucket中存储的元素复制到新数组中，并返回新数组。

get()方法

public V get(Object key) {Node<K,V> e;//对key进行hash计算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;//计算下标//first 该位置存储的第一个元素，可能是直接存储的元素，也可能是链表、红黑树的第一个节点if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {//先尝试匹配该位置第一个元素，匹配就直接返回if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))return first;//如果该位置存储了多个元素if ((e = first.next) != null) {//如果是红黑树方式存储的，则从红黑树中获取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);}}//没有匹配的元素时返回nullreturn null;
}

get()流程

对key进行hash计算，传给 getNode() 方法获取对应的键值对，再从键值对中获取value，不存在对应的键值对时返回null
getNode() 获取对应的键值对时，先计算数组下标，尝试匹配该位置存储的第一个元素，第一个元素匹配就直接返回，如果该位置存储了多个元素，则根据节点类型，从红黑树中获取匹配的键值对，或遍历链表获取匹配的键值对。

HashMap的常见问题

开发中用过哪些集合

list：ArrayList、LinkedList
set：HashSet、LinkedHashSet
map：HashMap、LinkedHashMap
juc：CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap

HashMap的数据结构，和之前版本的区别

jdk6、7：数组+链表，使用链表解决hash冲突
jdk8：数组+链表+红黑树，链表太长会影响哈希表的性能，所以引入了红黑树，链表长度大于8时会转换为红黑树，红黑树节点数量小于6时会退化为链表。总体来看，jdk8的HashMap比jdk7的性能高。

HashMap是如何解决哈希冲突的

使用拉链法，将哈希地址相同的元素存储在链表中。

HashMap使用的哈希算法是怎么实现的

static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

在key的hashCode基础上进行了位移、异或计算，位移16位是时间、空间上折中。

HashMap的容量为什么要是2的n次方

// 计算下标用的是 (n - 1) & hash
tab[i = (n - 1) & hash]

n是哈希表容量（数组长度），hash是 hash(key) 的结果。

将容量指定为2的次方，主要是为了计算哈希地址（数组下标）时的性能考虑

HashMap计算哈希地址（构建的哈希函数）实际使用的是除留余数法 hash % n，这种方式可以使计算得到的哈希地址比较均匀、分散。
n是2的次方时，hash % n 可以转换为 (n - 1) & hash，位运算 & 比取模 % 高效得多。
添加到链表中时是插入到链表头部还是尾部
jdk8之前：采用头插法，插入链表头部
jdk8及之后：头插法可能发生死循环问题，所以从jdk8开始采用尾插法，插入链表尾部，以解决死循环问题。

HashMap的死循环问题

HashMap不是线程安全的，多线程同时往同一个HashMap的同一个链表中插入元素时，可能出现环形链表，进而导致 get() 获取元素时出现死循环。

在多线程环境下，尽量用 ConcurrentHashMap 代替 HashMap。

hashCode()、equals()

Set体系

体系结构

常见实现类

HashSet

//内置的HashMap
private transient HashMap<E,Object> map;//键值对的value都指向此Object对象
private static final Object PRESENT = new Object();public HashSet() {map = new HashMap<>();
}public HashSet(Collection<? extends E> c) {map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));addAll(c);
}public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<>(initialCapacity, loadFactor);
}public HashSet(int initialCapacity) {map = new HashMap<>(initialCapacity);
}/*** 提供了一个默认访问权限的构造方法，留给子类 LinkedHashSet 使用，用于初始化为 LinkedHashMap* 注意：构造方法和普通方法一样，都可以使用public、protected、默认、private修饰*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

HashSet是通过内置的HashMap实现的，key存储元素，value指向同一个Object对象。

LinkedHashSet
继承自HashSet，实质是使用 LinkedHashMap实现，哈希表+双向链表。

TreeSet

//内置的可导航Map
private transient NavigableMap<E,Object> m;//map中存储的键值对，value都指向这个Object对象
private static final Object PRESENT = new Object();TreeSet(NavigableMap<E,Object> m) {this.m = m;
}//实质是通过TreeMap实现
public TreeSet() {this(new TreeMap<E,Object>());
}public TreeSet(Comparator<? super E> comparator) {this(new TreeMap<>(comparator));
}public TreeSet(Collection<? extends E> c) {this();addAll(c);
}public TreeSet(SortedSet<E> s) {this(s.comparator());addAll(s);
}

TreeSet实质是通过TreeMap实现的，键值对的value都指向同一个Object对象。

EnumSet
使用内置的 Enum<?>[ ] 存储枚举类实例。EnumSet并没有继承或者内置 EnumMap，但实现思路和EnumMap差不多。

性能比较

EnumSet：使用数组存储元素，不需要维护链表、树之类的数据结构，性能高。
HashSet：使用哈希表存储元素，增改删查性能不错
LinkedHashSet：在哈希表的基础上还要维护双向链表，增改删查速度比HashSet稍微差一些，但正因为用双向链表维护元素的添加顺序，遍历比HashSet快，可以做到按元素添加顺序进行遍历。
TreeSet：内部要维护红黑树，开销大。

这些set都不是线程安全的，多线程操作时需要用 Collections.synchronizedXxx() 转换为线程安全的集合，或者使用juc提供的CopyOnWriteArraySet、ConcurrentSkipListSet。

集合遍历

迭代器

单例集合可以直接使用迭代器，Map可以先获取key、value、Entry组成的单例集合，再获取对应的迭代器。

//写法一：hasNext() + next()
Iterator iterator=hashSet.iterator();
while (iterator.hasNext()){ System.out.println(iterator.next());// iterator.remove();
}

//写法二：函数式接口Consumer，其实是写法一的语法糖
hashSet.iterator().forEachRemaining(ele -> {System.out.println(ele);
});//要删除元素就不能连写，需要单独声明 iterator
Iterator<String> iterator = hashSet.iterator();
iterator.forEachRemaining(ele -> {System.out.println(ele);iterator.remove();
});

stream 流式操作

forEach

所有集合都可使用

set.forEach(ele->{//......
});map.forEach((key,value)->{//......
});

增强的for循环

所有集合都可使用

Set<Map.Entry> entrySet = map.entrySet();
Set<String> keySet = map.keySet();
Collection<String> valueCollection = map.values();for (Map.Entry<String, String> entry : entrySet) {String key = entry.getKey();String value = entry.getValue();
}

如果list这种元素关联了下标的，可以使用下标进行迭代

size() 获取已存储的元素个数。

集合工具类 Collections

Collections提供了大量的集合操作方法，包括查找最值、二分搜索、统计元素出现次数、替换、排序、反序、同步等，常见的如下

//空集合常量，本身不为null，只是集合内没有存储元素
Collections.EMPTY_LIST
Collections.EMPTY_SET
Collections.EMPTY_MAP//单例集合，集合中有且只能有1个元素
//不能调用remove之类的方法移除该元素，或调用add()之类的方法添加元素，否则会抛出 UnsupportedOperationException
List<String> list = Collections.singletonList("xxx");
Set<String> set = Collections.singleton("xxx");
Map<String, String> map = Collections.singletonMap("username", "chy");//转换为不可变集合
List<User> unmodifiableList = Collections.unmodifiableList(list);//转换为同步集合，线程安全，实质是在调用原集合的方法之前，使用 synchronized 加锁
List<User> synchronizedList = Collections.synchronizedList(list);

转换为不可变集合、同步集合都是：new新建集合实例，内部维护一个 final 修饰的对应集合，把原集合（的引用）赋给内部 final 集合。

不可变集合

不可变指的是内部final集合的引用不可变，不可变集合自身不能调用 add()、remove() 之类的方法增删元素，否则会抛出 UnsupportedOperationException。
由于不可变集合、原集合都指向同一个集合（引用相同），原集合是可以增删元素的，通过原集合的增删操作可以实现对不可变集合的增删。
可以修改元素内容，但不能修改元素自身的引用（对集合无效）

//原集合
List<User> list = new ArrayList<>();
User chy1 = new User(1L, "chy1");
list.add(chy1);//不可变集合
List<User> unmodifiableList = Collections.unmodifiableList(list);//修改元素内容，有效，集合中对应对象的username会变为xxx
chy1.setUsername("xxx");//修改元素引用，对集合来说无效，集合中对应的元素还是 User(1L, "chy1")，不会变成 User(2L, "chy2")
chy1 = new User(2L, "chy2");

array、list、set 的相互转换

list、set 的相互转换

直接调用对应的构造方法即可

List<String> list;
Set<String> set = new HashSet(list);

Set<String> set;
List<String> list = new ArrayList<>(set);

list、set 转 array

调用 list、set 的 toArray() 方法即可

List<String> list;
Set<String> set;//参数尽量指定目标数组（类型），如果使用空参的toArray()，返回Object[ ]
String[] arr1 = list.toArray(new String[list.size()]);
String[] arr2 = set.toArray(new String[list.size()]);//目标数组可以提出来声明，toArray()会复制元素到目标数组中，并返回目标数组
String[] arr = new String[list.size()];
list.toArray(arr);

array 转 list

使用工具类 Arrays 的静态方法 asList()

String[] arr;List<String> list1 = Arrays.asList(arr);//数组可以直接写成多个元素的形式。接收 T... t 这种元素数量可变的参数，本质是用数组去接收，相当于参数是数组类型
List<String> list2 = Arrays.asList("xxx1", "xxx2", "xxx3");

array 转 set

需要借助 list 中转一下

String[] arr;Set<String> set = new HashSet<>(Arrays.asList(arr));

使用集合的注意点

遍历

遍历集合时，不能使用集合本身的删除方法来删除集合元素，会直接抛出异常，可以使用迭代器的remove()来删除迭代器最近一次返回的元素，或使用stream来迭代集合。
使用迭代器遍历集合时，如果循环体内部又嵌套了迭代器，容易出问题，嵌套迭代尽量用增强for循环代替迭代器。

字符串、list的下标操作

通过下标操作时，一定要考虑下标是否合法、是否会越界。
使用 subXxx(start, end) 提取区间时，都是左闭右开 [start, end) ，如果 start==end ，返回的是空集合、空串。
使用 subXxx() 逐个区间提取时，最后一批的终止坐标应该是元素个数，即 list.size() 或 str.length()，这样才不会遗漏最后一个元素，实际并没有用到最后一个坐标，不会发生越界。

Arrays.asList()

ArrayList、HashSet 之类的普通集合，都可以正常使用 add()、remove() 之类的增删操作。

Arrays.asList() 返回的不是 java.util.ArrayList，而是Arrays的静态内部类 ArrayList，
虽然二者都 extends AbstractList\<E\> implements RandomAccess, java.io.Serializable，都是使用内置数组存储元素、具有很多相同方法，
但 Arrays的静态内部类 ArrayList 没有实现 add()、remove() 之类增删元素的方法，这些方法在 AbstractList 中的默认实现都是 throw new UnsupportedOperationException(); ，

所以调用 Arrays.asList() 时不要对返回的 list 进行增删操作，否则会抛出异常；如果需要进行增删操作，可以先转换为普通的list

ArrayList<String> list = new ArrayList<>(Arrays.asList("xxx1", "xxx2", "xxx3"));

空集合 Collections.emptyList()

集合为空、空集合是2个概念，集合为空是指集合自身没有初始化、是null，空集合是指集合自身已初始化（不为null）、但没有存储元素。

List<String> emptyList = Collections.emptyList();

返回的list是 Collections 的静态内部类 EmptyList 的实例，

EmptyList 和Arrays的静态内部类 ArrayList 一样，extends AbstractList<E> implements RandomAccess, Serializable，实现了 size()、isEmpty()、contains() 之类的方法，

但没有实现 add()、remove() 之类增删元素的方法，所以对 Collections.emptyList() 返回的空集合，不要进行元素增删操作，尤其注意不要直接 add() 添加元素，否则会抛出异常。