1 常见集合
集合相关类和接口都在java.util中，主要分为三中List(列表)、Map(映射)和Set(集合)
其中
Collection是集合List、Set的父接口，它主要有两个子接口：
List：存储的元素有序，可重复。
ArrayList基于数组实现
LinkedList基于双向链表实现
Set：存储的元素不无序，不可重复。
Map是另外的接口，是键值对映射结构的集合
2 ArrayList的扩容机制了解吗？
2.1 ArrayList如何指定底层数组大小的呢？
首先我们先看一下它的无参构造函数：此时我们以无参形式进行创建后，其数组容量为0。
只有当我们add元素时，才会给数组分配一个默认的初始容量 DEFAULT_CAPACITY = 10。
如果我们创建时并不使用无参构造，而使用有参构造。那么按照用户传入的大小开辟数组空间
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);
}
}扩容发生在啥时候？那肯定是我们往数组中新加入一个元素但是发现数组满了的时候
源码grow函数：看代码中的注释
private void grow(int minCapacity) {
// overflow-conscious code
// 获取旧数组长度
int oldCapacity = elementData.length;
// 新数组长度为旧数组的1.5倍 ！！
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);
}参考[1] 飞天小牛肉-送分题，ArrayList 的扩容机制了解吗？
3 有哪几种实现ArrayList线程安全的方法？
ArrayList的线程安全仍然没有保证，一般，保证ArrayList的线程安全可以通过这些方案：
使用 Vector 代替 ArrayList。（不推荐，Vector是一个历史遗留类）
使用 Collections.synchronizedList 包装 ArrayList，然后操作包装后的 list。
使用 CopyOnWriteArrayList 代替 ArrayList。
在使用 ArrayList 时，应用程序通过同步机制去控制 ArrayList 的读写。
4 CopyOnWriteArrayList了解多少？
既然已经提到了ArrayList是线程不安全的了。而且synchronizedList利用锁机制实现ArrayList的。
它的名字叫 CopyOnWrite —— 写时复制，已经明示了它的原理。
CopyOnWriteArrayList采用了一种读写分离的并发策略。CopyOnWriteArrayList容器允许并发读，读操作是无锁的，性能较高。至于写操作，比如向容器中添加一个元素，则首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器。
CopyOnWriteArrayList的add函数
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();
}
}5 Map
Map中，毫无疑问，最重要的就是HashMap！！！
Map中，毫无疑问，最重要的就是HashMap！！！
Map中，毫无疑问，最重要的就是HashMap！！！
以下内容采用的java版本为1.8.
5.1能说一下HashMap的数据结构吗？
说一下JDK1.8的数据结构吧：
JDK1.8的数据结构是 数组 + 链表 + 红黑树 。
其中，桶数组是用来存储数据元素，链表是用来解决冲突，红黑树是为了提高查询的效率
tips：
链表和红黑树之间可以相互转换。
数据元素通过映射关系，也就是散列函数， 映射到桶数组对应索引的位置
如果发生冲突， 从冲突的位置拉一个链表，插入冲突的元素
如果 链表长度>8&数组大小>=64，链表转为红黑树
如果 红黑树节点个数<6 ，转为链表
5.2 HashMap的put流程知道吗？
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 创建一个局部变量tab，p，n和i
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 为什么利用局部变量进行操作呢？这些变量都是在栈里面，提高性能。
if ((tab = table) == null || (n = tab.length) == 0)
// 初始化数组。resize的返回值为Node<k,v>[]。
n = (tab = resize()).length;
// 重新计算索引下标---此时相当于取余
if ((p = tab[i = (n - 1) & hash]) == null)
// 生成一个node对象存放到tab[i]的位置。
// ！！！此处会产生并发安全问题。
tab[i] = newNode(hash, key, value, null);
else {
// 如果计算出来的i位置已经被占用了，会进入这个else里面
Node<K,V> e; K k;
// 判断现有的key和待插入的key是否相同，相同则更新
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
// 待插入的节点是否是红黑树节点。
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 采用链表形式，解决hash冲突。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 用新值更新旧值
e.value = value;
afterNodeAccess(e);
// 返回旧值。
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}5.3 HashMap的resize流程知道吗？
作用1：生成新数组
作用2：元素迁移。
final Node<K,V>[] resize() {
// 1.生成新数组
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 判断扩容
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 初始化数组
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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;
// 2. 元素迁移。
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 orde r
// 要么相等，要么新 = 老 + 原始数组长度；
// 生成高低位链表
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;
}6 ConcurrentHashMap
HashMap不是并发安全的，因此需要用ConcurrentHashMap。
采用CAS+Synchorized
6.1 ConcurrentHashMap的put流程知道吗？
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 1. 计算hash值
int hash = spread(key.hashCode());
int binCount = 0;
// 死循环 相当于while(true)
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
// 2.1 如果数组还没有初始化，则进行初始化
tab = initTable();
// 2.2 已经进行初始化后，则计算当前key的下标。
// tabAt 采用unsafe拿到f = tab[i] 然后判断它是否为null
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 2.2.1通过cas操作将key 放到tab[i]
if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 2.3 moved = -1 表示由线程正在对，map进行扩容
else if ((fh = f.hash) == MOVED)
// 2.3.1 帮助扩容。
tab = helpTransfer(tab, f);
else {
// 2.4 向链表或者红黑树中插入链表。
V oldVal = null;
synchronized (f) {
// 重新检查
if (tabAt(tab, i) == f) {
// 表示链表上面的节点。
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
// 表示树上面的节点.
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
// 判断是否进树化。
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}6.2 ConcurrentHashMap的加1 和 扩容 流程知道吗？
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 1. 进行加1操作
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
// 2. 进行扩容---transfer 是真正的扩容。
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}transfer真正进行扩容。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 计算步长，最小为16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 进行双倍扩容。
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 扩容前数组的大小。
transferIndex = n;
}
int nextn = nextTab.length;
// 将一个桶中元素转移完以后会放置fwd对象。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 代表当前线程是否继续转移其他桶。
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
