Java 集合源码分析
目录
-
-
- 集合简介
- 迭代器
-
- Iterable接口
- Iterator 接口
- Collection接口
- List体系
-
- 体系结构
- List接口
- ArrayList源码解析
- Map体系
-
- 体系结构
- Map接口
- HashMap源码分析
- HashMap的常见问题
- hashCode()、equals()
- Set体系
-
- 体系结构
- 常见实现类
- 集合遍历
- 集合工具类 Collections
- array、list、set 的相互转换
- 使用集合的注意点
-
- 遍历时删除元素
- 下标操作
- Arrays.asList()、Collections.emptyList()
-
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个是流式操作的方法
@Override
default 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 Operations
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
// Modification Operations
boolean add(E e);
boolean remove(Object o);
// Bulk Modification Operations
boolean 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 hashing
boolean equals(Object o);
int hashCode();
// Positional Access Operations
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
// Search Operations
int indexOf(Object o);
int lastIndexOf(Object o);
// List Iterators
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
// View
List<E> subList(int fromIndex, int toIndex);
@Override
default 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;
//将存储的元素个数+1
size++;
}
//...
}
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) {
//容量改变次数+1
modCount++;
//如果目标容量大于当前容量，则调用 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_VALUE
if (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) // overflow
throw 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、hashCode
boolean 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 extends HashMap.Node 作为链表的节点
*/
static class Node<K,V> implements Map.Entry<K,V> {
//...
}
/**
* 红黑树节点。
* 间接继承了上面的 Node
*/
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;
}
}
//如果数组、链表或红黑树中已存在相同的key
if (e != null) { // existing mapping for key
V oldValue = e.value;
//如果onlyIfAbsent为false或原value是null，则直接覆盖原value
//put()传入的onlyIfAbsent是false，条件永真，都是直接覆盖原value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//留给LinkedHashMap的扩展点，用于同步向双向链表中更新节点
afterNodeAccess(e);
//返回原value
return oldValue;
}
}
//执行到此说明是新增操作，而非更新
//哈希表结构修改次数+1
++modCount;
//存储的元素数量+1。如果存储的元素数量超过阈值，则触发重哈希，进行扩容
if (++size > threshold)
resize();
//留给LinkedHashMap的扩展点，用于同步向双向链表中添加节点
afterNodeInsertion(evict);
//返回null
return 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 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;
}
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);
}
}
//没有匹配的元素时返回null
return 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()
相关问题
- 有没有重写过 hashcode()、equals()？是怎么重写的？
- 为什么重写 equals() 时必须重写 hashCode()？
为什么要使用hashCode | hashCode的作用
hashCode是专门给哈希表设计的，用于获取获取哈希码值，返回一个 int 型的整数作为哈希码值，在实现哈希表中起着重要作用。
根类Object的hashCode()是native方法，把对象的内存地址转换为int型的整数作为hashCode返回，如果对象的内存地址相同，则hashCode()返回的哈希码值也相同。
hashCode主要有2个作用
- 计算元素在哈希表中的存储位置（数组下标）
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
tab[i = (n - 1) & hash]
- 搭配 equals() 用于判断哈希表中是否已存在相同的key|元素
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
为什么要重写hashCode()、equals()
不重写hashCode()、equals()，默认使用根类Object的这2个方法，情况如下
HashMap<User, String> map = new HashMap<>();
User user = new User(1, "张三");
map.put(user, "vip");
user = new User(2, "李四");
map.put(user, "svip");
2个User对象都是new出来的，是不同的对象，它们的hashCode不同，equals()比较内存地址为true，所以都会放到map中。
HashMap<User, String> map = new HashMap<>();
User user = new User(1, "张三");
map.put(user, "vip");
user.setId(2);
user.setName("李四");
map.put(user, "svip");
复用User对象，使用的都是堆中的同一个对象，内存地址相同 => hashCode相同、equals()比较内存地址为true => 哈希表会认为key相同，所以第二个put()是更新操作，只更新对应的value，不会作为新的键值对添加。
从业务逻辑的角度来说，userId都变了，这显然是一个不同的用户，put()应该做添加而非更新。
重写hashCode()、equals()主要是基于业务逻辑上的考虑，确保使用同一个java对象存储不同实体对象的属性时也能被添加到哈希表中。
jdk自带的引用类型（包括String）都重写了 equals()、hashCode()，只需给要存储到哈希表中的、自定义的类重写。这里的存储到哈希表中指的是 HashMap中的key、HashSet中的元素，如果只是作为HashMap的value存储，则不必重写。
重写equals()时为什么要重写hashCode()
// hashCode相同 && (内存地址相同 || equals()为true )
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
因为是根据 hashCode、equals 共同判断哈希表中是否已存在相同的元素|key，只通过equals()无法判断，还需要借助 hashCode。此外根类Object约定
equals() 判断2个对象等价时，这2个对象的 hashCode() 返回的哈希码值也应该相同
所以重写equals()时也应该重写hashCode，确保在equals()返回true时，这2个对象返回的hashCode也相同。
重写hashCode()、equals()的基本原则|要求
equals() 判断2个对象等价，则这2个对象的 hashCode() 返回的哈希码值也应该相同。
这是个充分不必要条件，equals()为true，则hashCode一定相同；hashCode相同，equals()不一定为true。
这也是约定，可在Object类的 hashCode()、equals() 的方法注释上查看这些内容。
重写hashCode()、equals()示例
public class User {
private Integer id;
private String name;
private String tel;
//...
@Override
public int hashCode() {
// 使用id之类的标识性字段计算hashCode，可以直接返回int类型的字段值，也可以使用这些jdk自带的引用类型的重写的hashCode()方法
// return id.intValue();
return id.hashCode();
}
@Override
public boolean equals(Object obj) {
//如果另一个对象是null，当前对象自然不是null，直接返回false
if (obj == null) {
return false;
}
//如果内存地址相同，直接返回true
if (this == obj) {
return true;
}
//如果不是同一个类的实例，直接返回false。也可以用 instanceof 来判断
if (this.getClass() != obj.getClass()) {
return false;
}
//执行到此说明都不为null，且都是同一个类的实例，通过字段进行比较
User another = (User) obj;
//通常比较关键|主键字段即可。在类的内部可以直接访问当前类其它实例的成员变量，无需用getter方法
return id.equals(another.id);
}
}
//第三个if判断可以用 instanceof 来写
if (!(obj instanceof User)) {
return false;
}
User another = (User) obj;
//如果业务需要，可以逐字段比较
return id.equals(another.id) && name.equals(another.name) && tel.equals(another.tel);
以上使用的 id.hashCode()、id.equals(another.id) 代码都不健壮，id可能为null，可能发生NPE，使用前应该判断是否为null，或者使用工具类 Objects 中的方法代替
return id != null ? id.hashCode() : 0;
return (id == another.id) || (id != null && id.equals(another.id));
Objects.hashCode(id);
Objects.equals(id, another.id);
本质都是一样的
Objects的hashCode、equals()源码如下
public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
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。
集合遍历
很多集合都允许元素、key为null，迭代时注意NPE。
1、迭代器方式
//写法一：hasNext() + next()
Iterator iterator=list.iterator();
while (iterator.hasNext()){
T ele = iterator.next()
}
//写法二：函数式接口Consumer，实质是写法一的语法糖
iterator.forEachRemaining(ele -> {
});
使用迭代器遍历时，如果循环体内部又嵌套了迭代器，容易出问题，嵌套迭代尽量用增强for循环代替迭代器。
2、增强for循环
for (T ele : list) {
}
3、forEach，实质是对增强for循环的封装
set.forEach(ele -> {
});
map.forEach((key, value)->{
});
4、stream 流式操作
5、如果list这种有序、关联了index的，也可以用index进行迭代
集合工具类 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 的相互转换
//直接调用对应的构造方法即可
Set<String> set = new HashSet(list);
List<String> list = new ArrayList<>(set);
list、set 转 array
//调用 list、set 的 toArray() 方法即可
//参数尽量指定目标数组（类型），如果使用空参的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()，t... 个数可变的参数，本质也是用数组去接收
List<String> list1 = Arrays.asList(arr);
List<String> list2 = Arrays.asList("xxx1", "xxx2", "xxx3");
array 转 set
//需要借助list中转一下
Set<String> set = new HashSet<>(Arrays.asList(arr));
使用集合的注意点
遍历时删除元素
1、使用增强for循环、foreach 迭代集合，以及转换为 stream 使用 stream 的 forEach() 迭代时，不要用集合自身remove()方法移除元素，会抛出 ConcurrentModificationException。
2、在使用 fori 下标迭代集合时，不要用集合自身的remove()方法移除元素，因为移除元素后后续元素会自动前移（list中后续元素的index自动-1），而自增变量 i 却+1，导致遍历时会漏掉一些元素。当然，使用倒序删除可以避免此种问题
for (int i = list.size() - 1; i >= 0; i--) {
list.remove(list.get(i));
}
3、如果遍历集合时需要删除元素，尽量通过集合自身的removeIf、迭代器、stream filter去做
//方式一 迭代器，注意：要通过迭代器获取当前元素，才能使用迭代器移除当前元素
Iterator <String> iterator = list.iterator();
iterator.forEachRemaining(ele -> {
if (iterator.next() == null) {
iterator.remove();
}
// 错误代码，会抛出 IllegalStateException
// if (ele == null) {
// iterator.remove();
// }
});
while (iterator.hasNext()) {
if (iterator.next() == null) {
iterator.remove();
}
}
//方式二 集合自身的removeIf()，实质是迭代器方式的语法糖
list.removeIf(Objects::isNull);
//方式三 stream filter
list = list.stream()
.filter(Objects::nonNull)
.collect(Collectors.toList());
下标操作
String、arr、list
- 通过index操作时，一定要考虑下标是否合法、是否会越界。
- 使用 subXxx(start, end) 获取子区间时，都是左闭右开 [startIndex, endIndex) ； startIndex == endIndex 时 ，返回的是空集合、空串；分段处理时，最后一段的 endIndex 应该是元素个数，即 list.size() 或 str.length()，这样才不会漏掉最后一个元素。
Arrays.asList()、Collections.emptyList()
Arrays.asList() 返回的是Arrays的静态内部类 ArrayList，Collections.emptyList() 返回的是Collections的静态内部类EmptyList 的实例，
虽然二者都 extends AbstractList\，和ArrayList一样都是使用内置数组存储元素、具有 size()、isEmpty()、contains() 等很多相同的方法，但这2个静态内部类都没有实现 add()、remove() 之类增删元素的方法，这些方法在 AbstractList 中的默认实现都是 throw new UnsupportedOperationException(); ，调用会抛出异常，如果需要进行增删操作，可以先转换为普通的list。