系统的看一下Java支持的数据结构，记一下从数据结构到java实现的一些基础笔记。以下内容主要参考《java核心技术》与jdk11源码。

用于保存对象的数据结构一般称作容器类，也称作泛型集合（generic collection，由于容易和Collection接口混淆，因此有些书直接叫做容器类container library）。主要分为Collection和Map两种，Collection用于存储独立的元素，而Map用于存储“键值对”对象。

一些细节

在查找元素、查找位置、移除等操作中，判断对象是否相同的方式是调用equal函数。

retainAll(Collection<?> c)求两个集合的交集。

实现时接口与实现分离。使用时用满足需要的接口（如队列使用Queue），针对具体的场景new合适的实现。当需要自行实现对应的功能，为了降低实现接口中过多函数的复杂程度，可以直接扩展对应的Abastract类（如AbstractQueue），这种抽象接口加抽象类的方式在集合设计中经常遇到。

集合类只能容纳对象句柄。集合在存储基本类型时，会通过封装器（Integer等）将基本类型转换成普通类，因此在处理效率上不如数组（直接存储基本类型）。

迭代器 Iterator

public interface Iterator<E>{
  E next();
  boolean hasNext();
  void remove();
}
// 并没有一个函数直接返回迭代器指向位置的值

public interface Iterable<E>{
  Iterator<E> iterator();
}

for each循环可以针对任何实现了Iterable的对象（由编译器直接翻译成Iterator对应的代码）。for (String e: c){…}

Collection接口实现了Iterable接口，可以返回遍历元素的迭代器。

通过迭代器，能够用一套代码访问不同的容器类。

和C++的迭代器指向具体位置的设计不同，java的迭代器指向的位置可以看作是两个元素的中间。当调用next时，迭代器会跳过下一个元素，并返回被跳过元素的引用。不能像C++那样直接取当前位置的元素。对于remove函数，删除的是上一次next函数返回的位置（由于经常需要通过此位置的值判断是否删除）。也因此，每次调用remove函数前必须调用一次next方法，因此连续调用两次remove会出错。

List

ArrayList相当于dynamic array，随机访问快，随机插入慢。类似的实现还有Vector，相当于一个线程安全的ArrayList。

LinkedList，双向链表，随机访问慢，随机插入快。LinkedList比较特殊，除了List接口还是了双端队列的Deque接口。

LinkedList无法获取到node的指针，但可以通过获取ListIterator控制前后的位置（相对于Iterator，添加了previous等向前访问的函数）。

LikedList并没有缓存指针的位置，因此get(n)等随机访问和修改的操作效率不高。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

Map

《java核心技术》中将Map的介绍放在了Set之后，但是Hashset的实现直接使用了HashMap，此处先写写Map的实现。

HashMap

（下面的默认参数取自openjdk11源码）

实现常量时间的数据get和put。

HashMap用hashcode结合链表的实现。使用了桶（bucket）机制，将hashcode取余后放入一个链表，当一个桶中的数据达到8个时，会通过treeifyBin函数将链表的形式转成红黑树存储以加快检索效率。

在构造函数中设置了两个参数。threshold（默认为16）和loadFactor（默认为0.75），初始化时桶的数量会用threshold，往后threshold会等于 桶的数量×loadFactor。添加元素时，HashMap中的元素个数达到threshold时会调用resize让桶的数量翻倍，此时会遍历先前的所有元素添加到扩容之后的数组中（rehash过程）。

通过一个名为table的数组存储桶的节点，默认情况下的初始化桶的个数为16，每次会增加为之前的2倍，最大为Int型的最大值。

transient Node<K,V>[] table;

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

resize过程使用的头插入（新的table数组中插入的元素插入到链表头部，避免遍历到尾部的开销）。

当一个桶中的数据达到TREEIFY_THRESHOLD（8）个，并且桶的数量超过MIN_TREEIFY_CAPACITY（64）时，会在treeifyBin函数中将每个桶中的数据从链表转换成红黑树。

通过hashCode()函数得到hash值，通过equal()函数判断对象是否相等。

并发访问中，HashMap的实现中并没有考虑多线程的问题，在多线程结构化（structurally）修改HashMap时可能会出问题（结构化主要指添加和删除，修改某个key对应的值不算结构化修改）。

TreeMap

基于红黑树实现的Map，对于获取键值、插入、删除的操作时间复杂度为log(n)。put时将数据插入红黑树，get时从树中取数据。

由于数据存储在红黑树有序排列，获得排序后的数据较快。

将key-value键值对做为节点插入到红黑树中，由于需要排序，通过Comparator<? super K>接口让插入的键值可比较。

static final class Entry<K,V> implements Map.Entry<K,V> {
    K key;
    V value;
    Entry<K,V> left;
    Entry<K,V> right;
    Entry<K,V> parent;
    boolean color = BLACK;
	// ...
}

当类默认的比较函数不能满足需要时，可以另外定义新的comparator传入TreeMap。

public TreeMap(Comparator<? super K> comparator) {
    this.comparator = comparator;
}

EnumMap 用于枚举类型

所有的key必须是同一个enum类型中。内部通过数组的方式表达。每个类型对应数组中的一个元素。

put时直接获取key对应的enum位置，直接对数组中的此位置赋值。

private transient K[] keyUniverse;
private transient Object[] vals;

public V put(K key, V value) {
    typeCheck(key);
    int index = key.ordinal();
    Object oldValue = vals[index];
    vals[index] = maskNull(value);
    if (oldValue == null)
        size++;
    return unmaskNull(oldValue);
}

在put函数中，直接获取key对应的enum索引位置

LinkedHashMap实现原理

LinkedHashMap通过一个额外的双向链表链接所有的元素，通过构造函数中的参数accessOrder决定记录元素添加顺序还是元素访问顺序。

可以用来copy一个map，使新的map中的元素顺序与被赋值的map顺序相同（如下）。也适用于LRU cache类似的场景。

void foo(Map m) {
  Map copy = new LinkedHashMap(m);
  // ...
}

源码实现

总体逻辑为，每次添加新的元素，都回加入到链表的尾部。每次访问节点时，如果accessOrder为true（链表按照访问顺序），则将当前访问的节点放到链表尾部；当accessOrder为false（链表按照插入顺序），则不对链表操作。

通过两个指针可以获得所有元素的链表。

// The head (eldest) of the doubly linked list.
transient LinkedHashMap.Entry<K,V> head;

// The tail (youngest) of the doubly linked list.
transient LinkedHashMap.Entry<K,V> tail;

jdk11的实现上略微有点跳，不同于jdk8直接重写了关键函数，jdk11通过多态的形式插入了一些和HashMap不同的操作。

想象中的让链表记录元素插入顺序的方式，直接在put新的元素后，直接将新的元素加入到链表（记录元素访问顺序在get函数中类似）。jdk11在实现时，在HashMap类中定义了三个空函数用于在LinkedHashMap中实现：

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

三个函数分别在Node的访问、插入、删除三种情况后被调用，在HashMap中为空函数，LinkedHashMap中具体实现。但是，链表的插入顺序并没有直接放在afterNodeInsertion函数中，而是重写了创建新节点的newNode函数：

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
     Entry<K,V> p =
         new Entry<>(hash, key, value, e);
     linkNodeLast(p); // 将p节点通过tail指针添加到链表尾部
     return p;
}

其它Map

WeakHashMap 值不用后会被回收，利用了GC机制中的标记。

IdentityHashMap 用==而非equals比较键值。

Set

接口和Colection基本相同，除了java9加了几个针对不可变集合的函数。

public interface Set<E> extends Collection<E> {...}

Set的内部很多都直接使用上面的Map实现，如HashSet内部直接使用了HashMap做为存储，在添加元素时，将加入的元素作为key，用一个常量作为value。

private transient HashMap<E,Object> map; 
private static final Object PRESENT = new Object();

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

LinkedHashSet 记录了插入的顺序。

TreeSet使用了TreeMap，通过红黑树适用于需要排序的数据。

EnumSet包含枚举类型

Queue

ArrayDeque and LinkedList

Deque(double-ended queue）双端队列，发音为|deck|。

常见的队列主要有ArrayDeque（数组实现的双端循环队列）和 LinkedList（链表实现的双端队列），其中LinkedList虽然名字是List，但实现了Queue的函数，定义如下）。

通常情况下ArrayDeque的数组型实现效率会高于LinkedList的指针型实现。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
	//...
}

双端循环队列的addFirst函数实现如下

// 其中Deque表示“double end queue”，发音为deck
public interface Deque<E> extends Queue<E> {...}

// ArrayDeque使用的是循环队列
// addFirst函数会向队列头部加入一个新的元素
// 当头部为0时，会通过dec函数将head指针移到数组尾部对应的位置
public void addFirst(E e) {
    if (e == null)
        throw new NullPointerException();
    final Object[] es = elements;
    es[head = dec(head, es.length)] = e;
    if (head == tail)
        grow(1);
}

static final int dec(int i, int modulus) {
    if (--i < 0) i = modulus - 1;
    return i;
}

PriorityQueue

通过一个数组形式的堆实现最小优先队列，transient Object[] queue;，默认将最小值放在堆顶，peek()函数返回堆中最小值。没有直接的更改顺序的方式，如果需要将最大值放在堆顶需要传入Comparator接口的实现。

满足堆的性质，poll()函数返回队列中的最小值或者最大值O(log(n))。

Stack

public class Stack<E> extends Vector<E> {...}

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

LIFO (后进先出）

源码中的一些操作

位操作

用按位与操作提高取余效率

仅针对取余数为2^n次方的数。

对2取余实质上就是取2进制的最后一位，对4取余实质上是取2进制数的最后两位。

如 5 % 2 = （2进制）101 & 001。

2^n - 1 = （2进制的n个1）11….1

hash % n 等于 (n - 1) & hash

移位表示2^n

1 « 4 // 相当于2^4

当数组为2的倍数时，向左移m位相当于乘2的m次方

4 « m // 相当于 4*(2^m)

移位表示乘2和除2

22 » 1 // 除以二 22 « 1 // 乘2 22 »> 1 // 忽略符号位除以2

通过-1向右移位»>

对于8位的byte，-1 的源码为 10000001，因此可以通过»>得到一个00010000的2^n的数。

在HashMap中，hash桶的数量只能为2^n。下面的函数能够获取最小的n使2^n > cap。

/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

extendswind

Java数据结构笔记