目录
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<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;
}
}
//如果数组、链表或红黑树中已存在相同的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\<E\> implements RandomAccess, java.io.Serializable
,和ArrayList一样都是使用内置数组存储元素、具有 size()、isEmpty()、contains() 等很多相同的方法,但这2个静态内部类都没有实现 add()、remove() 之类增删元素的方法,这些方法在 AbstractList 中的默认实现都是 throw new UnsupportedOperationException();
,调用会抛出异常,如果需要进行增删操作,可以先转换为普通的list。