前言

本文快速回顾了Java中容器的知识点，用作面试复习，事半功倍。

其它知识点复习手册

概览

容器主要包括 Collection 和 Map 两种，Collection 又包含了 List、Set 以及 Queue。

Collection

数组和集合的区别:

  • 长度
    • 数组的长度固定
    • 集合的长度可变
  • 内容
    • 数组存储的是同一种类型的元素
    • 集合可以存储不同类型的元素(但是一般我们不这样干…)
  • 元素的数据类型
    • 数组可以存储基本数据类型,也可以存储引用类型
    • 集合只能存储引用类型(若存储的是简单的int，它会自动装箱成Integer)

1. Set（元素不可重复）

  • HashSet：基于HashMap实现，支持快速查找，但不支持有序性操作。

  • TreeSet：基于红黑树实现，支持有序性操作，但是查找效率不如 HashSet，HashSet 查找时间复杂度为 O(1)，TreeSet 则为 O(logN)；

  • LinkedHashSet：具有 HashSet 的查找效率，且内部使用链表维护元素的插入顺序。

2. List（有序(存储顺序和取出顺序一致)，可重复）

  • ArrayList：基于动态数组实现，支持随机访问；

  • Vector：和 ArrayList 类似，但它是线程安全的；

  • LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

3. Queue

  • LinkedList：可以用它来支持双向队列；

  • PriorityQueue：基于堆结构实现，可以用它来实现优先队列。

Map

  • HashMap：基于哈希实现；

  • HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。

  • ConcurrentHashMap：支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。

  • LinkedHashMap：使用链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

  • TreeMap：基于红黑树实现。

Fail-Fast 机制和 Fail-Safe 机制

https://blog.csdn.net/Kato_op/article/details/80356618

Fail-Fast

Fail-fast 机制是 java 集合(Collection)中的一种错误机制。 当多个线程对同一个集合的内容进行操作时，就可能会产生 fail-fast 事件。

  • 迭代器在遍历时直接访问集合中的内容,并且在遍历过程中使用一个modCount变量,

  • 集合中在被遍历期间如果内容发生变化(增删改),就会改变modCount的值,

  • 每当迭代器使用 hashNext()/next()遍历下一个元素之前,都会执行checkForComodification()方法检测，modCount变量和expectedmodCount值是否相等,

  • 如果相等就返回遍历,否则抛出异常,终止遍历.

注意，如果集合发生变化时修改modCount值, 刚好有设置为了expectedmodCount值, 则异常不会抛出.(比如删除了数据,再添加一条数据)

所以，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。

迭代器的快速失败行为应该仅用于检测程序错误, 而不是用他来同步。

java.util包下的集合类都是Fail-Fast机制的,不能在多线程下发生并发修改(迭代过程中被修改).

Fail-Safe

采用安全失败（Fail-Safe）机制的集合容器,在遍历时不是直接在集合内容上访问的，而是先copy原有集合内容,在拷贝的集合上进行遍历。

原理:

由于迭代时是对原集合的拷贝的值进行遍历,所以在遍历过程中对原集合所作的修改并不能被迭代器检测到,所以不会出发ConcurrentModificationException

缺点:

迭代器并不能访问到修改后的内容(简单来说就是, 迭代器遍历的是开始遍历那一刻拿到的集合拷贝,在遍历期间原集合发生的修改迭代器是不知道的)

使用场景:

java.util.concurrent包下的容器都是Fail-Safe的,可以在多线程下并发使用,并发修改

容器中使用的设计模式

迭代器模式

  • Iterator它是在ArrayList等集合的内部类的方式实现

Collection 实现了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。

从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
   
    System.out.println(item);
}

适配器模式

适配器模式解释：https://www.jianshu.com/p/93821721bf08

java.util.Arrays#asList() 可以把数组类型转换为 List 类型。

@SafeVarargs
public static <T> List<T> asList(T... a)

如果要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。

Integer[] arr = {
   1, 2, 3};
List list = Arrays.asList(arr);

也可以使用以下方式生成 List。

List list = Arrays.asList(1,2,3);

源码分析

ArrayList

关键词

  • 默认大小为 10
  • 扩容 1.5 倍，加载因子为 0.5
  • 基于动态数组实现
  • 删除元素时不会减少容量，若希望减少容量则调用trimToSize()
  • 它不是线程安全的
  • 它能存放null值。
  • 扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组
  • 删除需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。
    -序列化：只序列化数组中有元素填充那部分内容

概览

实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

扩容

如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1)，也就是旧容量的 1.5 倍。

扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中

因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

加入元素：add

add(E e)

首先去检查一下数组的容量是否足够

  • 足够：直接添加
  • 不足够：扩容

扩容到原来的1.5倍，第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。

add(int index, E element)

步骤：

  • 检查角标
  • 空间检查，如果有需要进行扩容
  • 插入元素

删除元素：remove

步骤：

  • 检查角标
  • 删除元素
  • 计算出需要移动的个数，并移动
  • 设置为null，让GC回收（所以说不是立刻回收，而是等待GC回收） 
public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。

复制数组：System.arraycopy()

看到arraycopy()，我们可以发现：该方法是由C/C++来编写的

Fail-Fast

modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。

在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
   
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
   
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
   
        throw new ConcurrentModificationException();
    }
}

构造器

ArrayList 提供了三种方式的构造器：

  • public ArrayList()可以构造一个默认初始容量为10的空列表；
  • public ArrayList(int initialCapacity)构造一个指定初始容量的空列表；
  • public ArrayList(Collection<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

序列化

补充：transient讲解

http://www.importnew.com/21517.html

你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。

保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。

transient Object[] elementData; // non-private to simplify nested class access

ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
   
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
   
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
   
            a[i] = s.readObject();
        }
    }
}

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
   
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
   
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
   
        throw new ConcurrentModificationException();
    }
}

序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。

ArrayList list = new ArrayList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(list);

Vector

关键词

  • 默认大小为 10（与Arraylist相同）
  • 扩容 2 倍，加载因子是 1（Arraylist是扩容 1.5 倍，加载因子为 0.5）
  • 其它几乎与ArrayList完全相同，唯一的区别在于 Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。
  • 使用了 synchronized 进行同步
  • Vector是jdk1.2的类了，比较老旧的一个集合类。应使用JUC的CopyOnWriteArrayList代替

替代方案

可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList。

List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);

也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。

List<String> list = new CopyOnWriteArrayList<>();

CopyOnWriteArrayList

关键词

  • 写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
  • 写操作需要加锁，防止并发写入时导致写入数据丢失。
  • 写操作结束之后需要把原始数组指向新的复制数组。
  • 适用于读操作远大于写操作的场景。

读写分离

public boolean add(E e) {
   
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
   
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
   
        lock.unlock();
    }
}

final void setArray(Object[] a) {
   
    array = a;
}

@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
   
    return (E) a[index];
}

适用场景

CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。

缺陷

  • 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
  • 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。

所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。

LinkedList

关键词

  • 双向链表
  • 默认大小为 10
  • 带 Head 和 Tail 指针
  • Node 存储节点信息

概览

基于双向链表实现，内部使用 Node 来存储链表节点信息。

private static class Node<E> {
   
    E item;
    Node<E> next;
    Node<E> prev;
}

每个链表存储了 Head 和 Tail 指针：

transient Node<E> first;
transient Node<E> last;

ArrayList 与 LinkedList 比较

  • ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
  • ArrayList 支持随机访问，LinkedList 不支持；
  • LinkedList 在任意位置添加删除元素更快。

删除元素：remove

获取元素：get

  • 下标小于长度的一半，从头遍历
  • 反之，从尾部遍历

替换元素：set

set方法和get方法其实差不多，根据下标来判断是从头遍历还是从尾遍历

其他方法

LinkedList实现了Deque接口，因此，我们可以操作LinkedList像操作队列和栈一样

LinkedList的方法比ArrayList的方法多太多了，这里我就不一一说明了。具体可参考：

HashMap

http://wiki.jikexueyuan.com/project/java-collection/hashmap.html

源码分析：https://segmentfault.com/a/1190000014293372

关键词

  • 初始容量16
  • 扩容是2倍，加载因子0.75
  • 头插法
  • 0桶存放null
  • 从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树（前提：键值对要超过64个）
  • 自动地将传入的容量转换为2的幂次方
    • 保证运算速度：确保用位运算代替模运算来计算桶下标。hash& (length-1)运算等价于对 length 取模。
    • hash均匀分布：数据在数组上分布就比较均匀，并且能够利用全部二进制位，也就是说碰撞的几率小，
  • table数组+Entry<K,V>[]链表（散列表），红黑树
  • 扩容操作需要把键值对重新插入新的 table 中，重新计算所有key有特殊机制（JDK1.8后）

存储结构

hashMap的一个内部类Node：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next; //链表结构，存储下一个元素

Node内部包含了一个 Entry 类型的数组table，数组中的每个位置被当成一个桶。

transient Entry[] table;

Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。

HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。

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

    Entry(int h, K k, V v, Entry<K,V> n) {
   
        value = v;
        next = n;
        key = k;
        hash = h;
    }

    public final K getKey() {
   
        return key;
    }

    public final V getValue() {
   
        return value;
    }

    public final V setValue(V newValue) {
   
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
   
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
   
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
   
        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }

    public final String toString() {
   
        return getKey() + "=" + getValue();
    }
}

构造器

构造时就会调用tableSizeFor()：返回一个大于输入参数且最近的2的整数次幂。

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;
}

拉链法

应该注意到链表的插入是以头插法方式进行的

HashMap<String, String> map = new HashMap<>();
map.put("K1", "V1");
map.put("K2", "V2");
map.put("K3", "V3");
  • 新建一个 HashMap，默认大小为 16；
  • 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
  • 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
  • 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。

查找需要分成两步进行：

  • 计算键值对所在的桶；
  • 在链表上顺序查找，时间复杂度显然和链表的长度成正比。

put 操作

  • 当我们 put 的时候，如果 key 存在了，那么新的 value 会代替旧的 value
  • 如果 key 存在的情况下，该方法返回的是旧的 value，
  • 如果 key 不存在，那么返回 null。 
public V put(K key, V value) {
   
    if (table == EMPTY_TABLE) {
   
        inflateTable(threshold);
    }
    // 键为 null 单独处理
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    // 确定桶下标
    int i = indexFor(hash, table.length);
    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
   
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
   
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    // 插入新键值对
    addEntry(hash, key, value, i);
    return null;
}

HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。

private V putForNullKey(V value) {
   
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
   
        if (e.key == null) {
   
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}

使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。

void addEntry(int hash, K key, V value, int bucketIndex) {
   
    if ((size >= threshold) && (null != table[bucketIndex])) {
   
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
   
    Entry<K,V> e = table[bucketIndex];
    // 头插法，链表头部指向新的键值对
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

Entry(int h, K k, V v, Entry<K,V> n) {
   
    value = v;
    next = n;
    key = k;
    hash = h;
}

补充：hashmap里hash方法的高位优化：

https://www.cnblogs.com/liujinhong/p/6576543.html

https://note.youdao.com/yws/res/18743/50AADC7BB42845B29CDA293FC409250C?ynotemdtimestamp=1548155508277

设计者将key的哈希值的高位也做了运算(与高16位做异或运算，使得在做&运算时，此时的低位实际上是高位与低位的结合)，这就增加了随机性，减少了碰撞冲突的可能性！

为何要这么做？

table的长度都是2的幂，因此index仅与hash值的低n位有关，hash值的高位都被与操作置为0了。

这样做很容易产生碰撞。设计者权衡了speed, utility, and quality，将高16位与低16位异或来减少这种影响。设计者考虑到现在的hashCode分布的已经很不错了，而且当发生较大碰撞时也用树形存储降低了冲突。仅仅异或一下，既减少了系统的开销，也不会造成的因为高位没有参与下标的计算(table长度比较小时)，从而引起的碰撞。

确定桶下标

很多操作都需要先确定一个键值对所在的桶下标。

int hash = hash(key);
int i = indexFor(hash, table.length);

4.1 计算 hash 值

final int hash(Object k) {
   
    int h = hashSeed;
    if (0 != h && k instanceof String) {
   
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

public final int hashCode() {
   
    return Objects.hashCode(key) ^ Objects.hashCode(value);
}

4.2 取模

令 x = 1<<\4，即 \x 为 2 的 4 次方，它具有以下性质：

x   : 00010000
x-1 : 00001111

令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：

y       : 10110010
x-1     : 00001111
y&(x-1) : 00000010

这个性质和 y 对 x 取模效果是一样的：

y   : 10110010
x   : 00010000
y%x : 00000010

我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。

确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。

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

当 length 总是 2 的 n 次方时，h& (length-1)运算等价于对 length 取模，也就是 h%length，但是 & 比 % 具有更高的效率。这看上去很简单，其实比较有玄机的，我们举个例子来说明：

h & (table.length-1) hash table.length-1
8 & (15-1)： 0100 & 1110 = 0100
9 & (15-1)： 0101 & 1110 = 0100
8 & (16-1)： 0100 & 1111 = 0100
9 & (16-1)： 0101 & 1111 = 0101

  • 从上面的例子中可以看出：当它们和 15-1（1110）“与”的时候，8 和 9产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8 和 9 会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链 表，得到8或者9，这样就降低了查询的效率。

  • 同时，我们也可以发现，当数组长度为 15 的时候，hash 值会与 15-1（1110）进行“与”，那么最后一位永远是 0，而 0001，0011，0101，1001，1011，0111，1101 这几个位置永远都不能存放元素了，空间浪费相当大，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率。

  • 而当数组长度为16时，即为2的n次方时，2n-1 得到的二进制数的每个位上的值都为 1，这使得在低位上&时，得到的和原 hash 的低位相同，加之 hash(int h)方法对 key 的 hashCode 的进一步优化，加入了高位计算，就使得只有相同的 hash 值的两个值才会被放到数组中的同一个位置上形成链表。

所以说，当数组长度为 2 的 n 次幂的时候，不同的 key 算得得 index 相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小

扩容-基本原理

设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。

为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。

和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。

参数 含义
capacity table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。
size 键值对数量。
threshold size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。
loadFactor 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。 
static final int DEFAULT_INITIAL_CAPACITY = 16;

static final int MAXIMUM_CAPACITY = 1 << 30;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

transient Entry[] table;

transient int size;

int threshold;

final float loadFactor;

transient int modCount;

从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。

void addEntry(int hash, K key, V value, int bucketIndex) {
   
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    if (size++ >= threshold)
        resize(2 * table.length);
}

扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。

void resize(int newCapacity) {
   
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
   
        threshold = Integer.MAX_VALUE;
        return;
    }
    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

void transfer(Entry[] newTable) {
   
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
   
        Entry<K,V> e = src[j];
        if (e != null) {
   
            src[j] = null;
            do {
   
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}

扩容-重新计算桶下标

Rehash优化：https://my.oschina.net/u/3568600/blog/1933764

在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。

假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：

capacity     : 00010000
new capacity : 00100000

对于一个 Key，

  • 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
  • 如果为 1，那么得到的结果为原来的结果 +16。

总结：

经过rehash之后，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

计算数组容量

HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。

先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：

mask |= mask >> 1    11011000
mask |= mask >> 2    11111110
mask |= mask >> 4    11111111

mask+1 是大于原始数字的最小的 2 的 n 次方。

num     10010000
mask+1 100000000

以下是 HashMap 中计算数组容量的代码：

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;
}

链表转红黑树

并不是桶子上有8位元素的时候它就能变成红黑树，它得同时满足我们的键值对大于64才行的

这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。

HashTable

关键词：

  • Hashtable的迭代器不是 fail-fast，HashMap 的迭代器是 fail-fast 迭代器。
  • Hashtable 的 key 和 value 都不允许为 null，HashMap 可以插入键为 null 的 Entry。
  • HashTable 使用 synchronized 来进行同步。
  • 基于 Dictionary 类（遗留类）
  • HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

HashMap 与 HashTable

  • HashTable 基于 Dictionary 类（遗留类），而 HashMap 是基于 AbstractMap。
    • Dictionary 是任何可将键映射到相应值的类的抽象父类，
    • 而AbstractMap是基于Map接口的实现，它以最大限度地减少实现此接口所需的工作。
  • HashMap 的 key 和 value 都允许为 null，而 Hashtable 的 key 和 value 都不允许为 null
  • HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
  • 由于 Hashtable 是线程安全的也是 synchronized，所以在单线程环境下它比 HashMap 要慢。
  • Hashtable 中的几乎所有的 public 的方法都是synchronized的，而有些方法也是在内部通过 synchronized 代码块来实现。
    • 但是在 Collections 类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的 Map 对象，并把它作为一个封装的对象来返回。
    • 也可以使用 ConcurrentHashMap，它是 HashTable 的替代，而且比 HashTable 可扩展性更好

ConcurrentHashMap

谈谈ConcurrentHashMap1.7和1.8的不同实现：

http://www.importnew.com/23610.html

详细源码分析（还未细看）：

https://blog.csdn.net/yan_wenliang/article/details/51029372

https://segmentfault.com/a/1190000014380257

主要针对jdk1.7的实现来介绍

关键词

  • key和value都不允许为null
  • Hashtable是将所有的方法进行同步，效率低下。而ConcurrentHashMap通过部分锁定+CAS算法来进行实现线程安全的
  • get方法是非阻塞，无锁的。重写Node类，通过volatile修饰next来实现每次获取都是最新设置的值
  • 在高并发环境下，统计数据(计算size…等等)其实是无意义的，因为在下一时刻size值就变化了。
  • 实现形式不同：
    • 1.7：Segment + HashEntry的方式进行实现
    • 1.8：与HashMap相同（散列表（数组+链表）+红黑树）采用Node数组 + CAS + Synchronized来保证并发安全进行实现

存储结构

jdk1.7

jdk1.7中采用Segment + HashEntry的方式进行实现

Segment：其继承于 ReentrantLock 类，从而使得 Segment 对象可以充当锁的角色。

Segment 中包含HashBucket的数组，其可以守护其包含的若干个桶。

static final class HashEntry<K,V> {
   
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K,V> next;
}

ConcurrentHashMap采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。

jdk1.8

  • JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。

  • JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。

  • 并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。

1.8中放弃了Segment臃肿的设计，取而代之的是采用Node数组 + CAS + Synchronized来保证并发安全进行实现

添加元素：put

只让一个线程对散列表进行初始化！

获取元素：get

从顶部注释我们可以读到，get方法是不用加锁的，是非阻塞的。

Node节点是重写的，设置了volatile关键字修饰，致使它每次获取的都是最新设置的值

获取大小：size

每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。

在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。

ConcurrentHashMap 在执行 size操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。

尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。

如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。

删除元素：remove

为什么用这么方式删除呢，细心的同学会发现上面定义的HashEntry的key和next都是final类型的，所以不能改变next的指向，所以又复制了一份指向删除的结点的next。

Collections.synchronizedMap()与ConcurrentHashMap的区别

参考：https://blog.csdn.net/lanxiangru/article/details/53495854

  • Collections.synchronizedMap()和Hashtable一样，实现上在调用map所有方法时，都对整个map进行同步，而ConcurrentHashMap的实现却更加精细，它对map中的所有桶加了锁，同步操作精确控制到桶，所以，即使在遍历map时，其他线程试图对map进行数据修改，也不会抛出ConcurrentModificationException。
  • ConcurrentHashMap从类的命名就能看出，它是个HashMap。而Collections.synchronizedMap()可以接收任意Map实例，实现Map的同步。比如TreeMap。

总结

ConcurrentHashMap 的高并发性主要来自于三个方面：

  • 用分离锁实现多个线程间的更深层次的共享访问。
  • 用 HashEntery对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求。
  • 通过对同一个 Volatile 变量的写 / 读访问，协调不同线程间读 / 写操作的内存可见性。

LinkedHashMap

http://wiki.jikexueyuan.com/project/java-collection/linkedhashmap.html

https://segmentfault.com/a/1190000014319445

关键词

  • 允许使用 null 值和 null 键
  • 此实现不是同步的（linkedlist，lilnkedhashset也不是同步的）
  • 维护着一个运行于所有条目的双向链表。定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
  • 初始容量对遍历没有影响：遍历的双向链表，而不是散列表
  • 在访问顺序的情况下，使用get方法也是结构性的修改（会导致Fail-Fast）

概论

成员变量

该 Entry 除了保存当前对象的引用外，还保存了其上一个元素 before 和下一个元素 after的引用，从而在哈希表的基础上又构成了双向链接列表。

/**
* LinkedHashMap的Entry元素。
* 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。
 */
static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

构造器

  • 通过源代码可以看出，在 LinkedHashMap 的构造方法中，实际调用了父类 HashMap 的相关构造方法来构造一个底层存放的 table 数组，但额外可以增加 accessOrder 这个参数，如果不设置

    • 默认为 false，代表按照插入顺序进行迭代；
    • 当然可以显式设置为 true，代表以访问顺序进行迭代。

  • 在构建新节点时，构建的是LinkedHashMap.Entry 不再是Node.

获取元素：get

LinkedHashMap 重写了父类 HashMap 的 get 方法，实际在调用父类 getEntry() 方法取得查找的元素后，再判断当排序模式 accessOrder 为 true 时，记录访问顺序，将最新访问的元素添加到双向链表的表头，并从原来的位置删除。

由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。

遍历元素

为啥注释说：初始容量对遍历没有影响？

因为它遍历的是LinkedHashMap内部维护的一个双向链表，而不是散列表(当然了，链表双向链表的元素都来源于散列表)

LinkedHashMap应用

http://wiki.jikexueyuan.com/project/java-collection/linkedhashmap-lrucache.html

LRU最近最少使用（访问顺序）

用这个类有两大好处：

  • 它本身已经实现了按照访问顺序或插入顺序的存储
  • LinkedHashMap 本身有removeEldestEntry方法用于判断是否需要移除最不常读取的数，但是，原始方法默认不需要移除，我们需要override这样一个方法。

Java里面实现LRU缓存通常有两种选择：

  • 使用LinkedHashMap
  • 自己设计数据结构，使用链表+HashMap

以下是使用 LinkedHashMap 实现的一个 LRU 缓存：

  • 设定最大缓存空间 MAX_ENTRIES 为 3；
  • 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
  • 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。 
class LRUCache<K, V> extends LinkedHashMap<K, V> {
   
    private static final int MAX_ENTRIES = 3;

    protected boolean removeEldestEntry(Map.Entry eldest) {
   
        return size() > MAX_ENTRIES;
    }

    LRUCache() {
   
        super(MAX_ENTRIES, 0.75f, true);
    }
}

public static void main(String[] args) {
   
    LRUCache<Integer, String> cache = new LRUCache<>();
    cache.put(1, "a");
    cache.put(2, "b");
    cache.put(3, "c");
    cache.get(1);
    cache.put(4, "d");
    System.out.println(cache.keySet());
}

[3, 1, 4]

实现详细代码请参考文章：补充知识点-缓存

FIFO（插入顺序）

还可以在插入顺序的LinkedHashMap直接重写下removeEldestEntry方法即可轻松实现一个FIFO缓存

TreeMap

关键词

  • 红黑树
  • 非同步
  • key不能为null
  • 实现了NavigableMap接口，而NavigableMap接口继承着SortedMap接口，是有序的（HahMap是Key无序的）
  • TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
  • 适用于查找性能要求不那么高，反而对有序性要求比较高的应用场景
  • 使用Comparator或者Comparable来比较key是否相等与排序的问题

概览

获取元素：get

详细看：

https://segmentfault.com/a/1190000014345983#articleHeader4

总结：

  • 如果在构造方法中传递了Comparator对象，那么就会以Comparator对象的方法进行比较。否则，则使用Comparable的compareTo(T o)方法来比较。
  • 值得说明的是：如果使用的是compareTo(T o)方法来比较，key一定是不能为null，并且得实现了Comparable接口的。
  • 即使是传入了Comparator对象，不用compareTo(T o)方法来比较，key也是不能为null的

删除元素：remove

删除节点并且平衡红黑树

HashSet

http://wiki.jikexueyuan.com/project/java-collection/hashset.html

https://segmentfault.com/a/1190000014391402

关键词：

  • 默认容量16，扩容两倍，加载因子0.75

  • 允许元素为null

  • 实现Set接口

  • 不保证迭代顺序

  • 非同步

  • 初始容量非常影响迭代性能

  • 底层实际上是一个HashMap实例

    public HashSet() {map = new HashMap<>();}

如果添加的是在 HashSet 中不存在的，则返回 true；如果添加的元素已经存在，返回 false。

对于 HashSet 中保存的对象，请注意正确重写其 equals 和 hashCode 方法，以保证放入的对象的唯一性。

HashSet 和 HashMap 的区别

重要：

1. HashMap中使用键对象来计算hashcode值

2. HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false

TreeSet

关键词

  • 实现NavigableSet接口
  • 可以实现排序功能
  • 底层实际上是一个TreeMap实例
  • 非同步
  • 不允许为null

LinkedHashSet

关键词

  • 迭代是有序的
  • 允许为null
  • 底层实际上是一个HashMap+双向链表实例(其实就是LinkedHashMap)
  • 非同步
  • 性能比HashSet差一丢丢，因为要维护一个双向链表
  • 初始容量与迭代无关（与LinkedHashMap相同），因为LinkedHashSet迭代的是双向链表

总结Set

HashSet：

  • 无序，允许为null，底层是HashMap(散列表+红黑树)，非线程同步

TreeSet：

  • 有序，不允许为null，底层是TreeMap(红黑树),非线程同步

LinkedHashSet：

  • 迭代有序，允许为null，底层是HashMap+双向链表，非线程同步

WeekHashMap

存储结构

WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。

WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>

ConcurrentCache

Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。

ConcurrentCache 采取的是分代缓存：

  • 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
  • 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
  • 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
  • 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。 
public final class ConcurrentCache<K, V> {
   

    private final int size;

    private final Map<K, V> eden;

    private final Map<K, V> longterm;

    public ConcurrentCache(int size) {
   
        this.size = size;
        this.eden = new ConcurrentHashMap<>(size);
        this.longterm = new WeakHashMap<>(size);
    }

    public V get(K k) {
   
        V v = this.eden.get(k);
        if (v == null) {
   
            v = this.longterm.get(k);
            if (v != null)
                this.eden.put(k, v);
        }
        return v;
    }

    public void put(K k, V v) {
   
        if (this.eden.size() >= size) {
   
            this.longterm.putAll(this.eden);
            this.eden.clear();
        }
        this.eden.put(k, v);
    }
}

常见问题总结

Enumeration和Iterator接口的区别

Iterator替代了Enumeration，Enumeration是一个旧的迭代器了。

与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。

区别有三点：

  • Iterator的方法名比Enumeration更科学
  • Iterator有fail-fast机制，比Enumeration更安全
  • Iterator能够删除元素，Enumeration并不能删除元素

ListIterator有什么特点

  • ListIterator继承了Iterator接口，它用于遍历List集合的元素。
  • ListIterator可以实现双向遍历,添加元素，设置元素

与Java集合框架相关的有哪些最好的实践

如果是单列的集合，我们考虑用Collection下的子接口ArrayList和Set。

如果是映射，我们就考虑使用Map

  • 是否需要同步：去找线程安全的集合类使用

  • 迭代时是否需要有序(插入顺序有序)：去找Linked双向列表结构的

  • 是否需要排序(自然顺序或者手动排序)：去找Tree红黑树类型的(JDK1.8)

  • 估算存放集合的数据量有多大，无论是List还是Map，它们实现动态增长，都是有性能消耗的。在初始集合的时候给出一个合理的容量会减少动态增长时的消耗

  • 使用泛型，避免在运行时出现ClassCastException

  • 尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性

参考

关注我

本人目前为后台开发工程师，主要关注Python爬虫，后台开发等相关技术。

原创博客主要内容：

  • 笔试面试复习知识点手册
  • Leetcode算法题解析（前150题）
  • 剑指offer算法题解析
  • Python爬虫相关实战
  • 后台开发相关实战

同步更新以下几大博客：