1、常用List
ArrayList：底层是数组实现 Object[]，线程不安全，查询和修改⾮常快，但是增加和删除慢；查询/修改多时使用；
LinkedList: 底层是双向链表 Node<E>，线程不安全，查询和修改速度慢，但是增加和删除速度快；删除/新增多时使用；
Vector: 底层是数组实现 Object[]，线程安全的，操作indexof/size/remove/add等的时候使⽤synchronized进⾏加锁；已经很少使用了；
2、线程安全List
自写list：自己写个类，继承ArrayList，每个方法都加上锁；
Collections.synchronizedList(new ArrayList<>())：几乎所有的方法都加了synchronized；读写没什么区别；
CopyOnWriteArrayList<>()：执行修改操作时，先获取ReentrantLock锁，然后创建一个长度+1的新书组，将数据拷贝到新数组，加入新数据，然后将原集合指向新集合，最后释放锁；
1 //CopyOnWriteArrayList 源代码
2 public boolean add(E e) {
3 final ReentrantLock lock = this.lock;
4 lock.lock();
5 try {
6 Object[] elements = getArray();
7 int len = elements.length;
8 Object[] newElements = Arrays.copyOf(elements, len + 1);
9 newElements[len] = e;
10 setArray(newElements);
11 return true;
12 } finally {
13 lock.unlock();
14 }
15 }
CopyOnWriteArrayList：读没有加锁，修改操作（add、set、 remove等)加锁，写代价较高，若复制大对象有可能发生Full GC；读写分离+最终一致；适合 少写多读 的场景；
Collections.synchronizedList：读写均加锁synchronized，写操作较多时使用；
两者相比，写性能好-Collections.synchronizedList，读性能好-CopyOnWriteArrayList；
3、ArrayList扩容机制
JDK7及之前，ArrayList创建时，默认大小是10，增加第11个时扩容，扩容为原来的1.5倍，类似饿汉式；
JDK8及之后，默认是null，无长度，增加第1个时初始化为10，类似懒汉式；
add时判断扩容流程：
第一次添加元素，先判断大小是否是0，如果是0，则扩容到10；
若元素个数大于其容量，则扩容为 原始⼤⼩+原始⼤⼩/2；
判断与扩容 实现逻辑：传入添加元素后的新容量值，原数组判空，新容量值一直取大（默认容量值、旧容量扩后值），创建新数组，拷贝数据，指针指向；
//源码入口
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//判断是否是空的
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//默认与传入值取大
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//扩容后 = 原始⼤⼩+原始⼤⼩/2
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
add方法：先 判断与扩容，数组目前位置 +1 塞新值；
get方法：先判空，再判传入index是否超出范围，最后直接返回数据index位置数据；
indexOf方法：先判传参数是否是null，null是循环判==null，非空是循环equals判是否相同，返回index；
remove方法：先判空，再判传入index是否超出范围，最后 依次移动后边元素；
System.arraycopy(Object src 原数组, int srcPos 起始位置, Object dest 目标数组, int destPos 目标位置,int length 拷贝长度)；
System.arraycopy(elementData, index, elementData, index+1,numMove)；
4、常用map
HashMap：底层是基于数组+链表，⾮线程安全的，默认容量是16、允许有空的健和值；一般用于删除与元素定位；
Hashtable：基于哈希表实现，线程安全的(加了synchronized)，默认容量是11，不允许有 null的健和值；一般不怎么用；
treeMap：使⽤存储结构是⼀个平衡⼆叉树->红⿊树，默认是生序；可以⾃定义排序规则，要实现Comparator接⼝；一般用于排序；
按照添加顺序使⽤LinkedHashMap，按照⾃然排序使⽤TreeMap，⾃定义排序 TreeMap(Comparetor c，重写compare)；
ConcurrentHashMap：也是基于数组+链表，线程安全；虽然是线程安全，但是他的效率⽐Hashtable要⾼很多；
Collections.synchronizedMap()：线程安全，几乎所有的方法都加了synchronized；
hashcode：顶级类Object的⽅法，所有类都是继承Object,返回是⼀个int类型的数 根据⼀定的hash规则(存储地址，字段，⻓长度等)，映射成⼀个数组，即散列值；
equals：顶级类Object的⽅法，所有的类都是继承Object,返回是⼀个boolean类型 根据⾃定义的匹配规则，⽤于匹配两个对象是否⼀样；引用类型/字段匹配等；
Set，不保存重复数据，是对对应map的封装，HashSet对应的就是HashMap，treeSet对应的就是treeMap；
//HashSet源码
public HashSet() {
map = new HashMap<>();
}
private static final Object PRESENT = new Object();
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
5、map源码-HashMap与ConcurrentHashMap
HashMap底层是 数组+链表+红⿊树 (JDK8才有红⿊树，链表长度大于8，转红黑树)
Node<K,V>[] table 数组，数组每个元素都是Node的首节点，Node实现了Map.Entry<K,V>接口，每个节点都是key-value的键值对，且每个节点都指向下一个节点；
1 static class Node<K,V> implements Map.Entry<K,V> {
2 final int hash;
3 final K key;
4 V value;
5 Node<K,V> next;
.....
transient Node<K,V>[] table;
hash碰撞：不同key计算得到的Hash值相同，hashmap是链表发，要放到同个bucket中；
解决hash碰撞：链表法、开发地址法、再哈希法等
底层结构好处：
链表能解决hash冲突，将hash值相同的对象存在同⼀个链表中，并放在hash值对应的数组位；
数据较少时（少于8个），遍历线性表⽐红⿊树快；
红⿊树能提升查找数据的速度，红⿊树是平衡⼆叉树，插⼊新数据后会通过左旋，右旋、变 ⾊等操作来保持左右平衡，解决单链表查询深度的问题；
ConcurrentHashMap，在结构上无任何区别，仅仅在方法上有区别，如取spread重哈希，加锁synchronized锁，利⽤CAS获取数据；
JDK1.7： 扩容头插法，多线程同时扩容重新塞node时，易形成环；JDK1.8：扩容尾插法；
允许null值（null对应哈希是0），Integer和String更适合做key（具有不可变性），顺序与插入顺序无关，且会随着扩容而发生变化
6、map的put方法
HashMap 流程：
当前数组是否为空，空则扩容；
hash值命中的数组下标，是否空，空则直接创建节点塞值；
下标为非空，判断首节点key是否一致，一致则替换；
否则，判树形 树形插入，链表 循环判值 替换或插入 校验转红黑树；
统一 校验并扩容；
HashMap 底层源码如下：
1 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
2 boolean evict) {
3 HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
4 //数组判空
5 if ((tab = table) == null || (n = tab.length) == 0)
6 //扩容
7 n = (tab = resize()).length;
8 //数组hash获取下标位是否为空
9 if ((p = tab[i = (n - 1) & hash]) == null)
10 //空直接创建节点
11 tab[i] = newNode(hash, key, value, null);
12 else {
13 //非空，判断首节点是否key一致
14 HashMap.Node<K,V> e; K k;
15 if (p.hash == hash &&
16 ((k = p.key) == key || (key != null && key.equals(k))))
17 e = p;
18 //是否树结构
19 else if (p instanceof HashMap.TreeNode)
20 e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
21 else {
22 //非树结构，循环 判一致 替换，null 新增 判长度转红黑树
23 for (int binCount = 0; ; ++binCount) {
24 if ((e = p.next) == null) {
25 p.next = newNode(hash, key, value, null);
26 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
27 treeifyBin(tab, hash);
28 break;
29 }
30 if (e.hash == hash &&
31 ((k = e.key) == key || (key != null && key.equals(k))))
32 break;
33 p = e;
34 }
35 }
36 if (e != null) {
37 V oldValue = e.value;
38 if (!onlyIfAbsent || oldValue == null)
39 e.value = value;
40 afterNodeAccess(e);
41 return oldValue;
42 }
43 }
44 //扩容
45 ++modCount;
46 if (++size > threshold)
47 resize();
48 afterNodeInsertion(evict);
49 return null;
50 }
ConcurrentHashMap：
hashtable类所有的⽅法几乎都加锁synchronized，线程安全 ⾼并发效率低；
JDK8前，ConcurrentHashMap使⽤锁分段技术，将数据分成⼀段段存储，每个数据段配置⼀把锁segment类，这个类继承ReentrantLock来保证线程安全 技术点：Segment+HashEntry；
JKD8后取消Segment，底层也是使⽤Node数组+链表+红⿊树，CAS(读)+Synchronized(写) 技术点：Node+Cas+Synchronized；
spread(key.hashCode()) 重哈希，减少碰撞概率；
tabAt(i) 获取table中索引为i的Node元素；
casTabAt(i) 利⽤CAS操作获取table中索引为i的Node元素；
ConcurrentHashMap逻辑是：
取重哈希，循环表，空表初始化；
hash值命中的数组下标，是否空，空则利用cas直接创建节点塞值；
下标为非空，判扩容 锁首节点；
判是链表，循环链表，判key是否一致，一致则替换，null则直接插入 大于8转红黑树；
否则，判树形 树形插入；
统一 校验并扩容；
ConcurrentHashMap源码如下：
1 final V putVal(K key, V value, boolean onlyIfAbsent) {
2 if (key == null || value == null) throw new NullPointerException();
3 //取重哈希
4 int hash = spread(key.hashCode());
5 int binCount = 0;
6 //直接无限循环数组
7 for (ConcurrentHashMap.Node<K,V>[] tab = table;;) {
8 ConcurrentHashMap.Node<K,V> f; int n, i, fh;
9 //空数组，初始化
10 if (tab == null || (n = tab.length) == 0)
11 tab = initTable();
12 //数组hash获取下标位是否为空
13 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
14 //利用cas出入节点
15 if (casTabAt(tab, i, null, new ConcurrentHashMap.Node<K,V>(hash, key, value, null)))
16 break;
17 }
18 //判断是否需要先扩容
19 else if ((fh = f.hash) == MOVED)
20 tab = helpTransfer(tab, f);
21 else {
22 V oldVal = null;
23 //hash冲突，加锁
24 synchronized (f) {
25 if (tabAt(tab, i) == f) {
26 //是链表，循环
27 if (fh >= 0) {
28 binCount = 1;
29 for (ConcurrentHashMap.Node<K,V> e = f;; ++binCount) {
30 K ek;
31 if (e.hash == hash &&
32 ((ek = e.key) == key ||
33 (ek != null && key.equals(ek)))) {
34 oldVal = e.val;
35 if (!onlyIfAbsent)
36 e.val = value;
37 break;
38 }
39 ConcurrentHashMap.Node<K,V> pred = e;
40 if ((e = e.next) == null) {
41 pred.next = new ConcurrentHashMap.Node<K,V>(hash, key,
42 value, null);
43 break;
44 }
45 }
46 }
47 //是树
48 else if (f instanceof ConcurrentHashMap.TreeBin) {
49 ConcurrentHashMap.Node<K,V> p;
50 binCount = 2;
51 if ((p = ((ConcurrentHashMap.TreeBin<K,V>)f).putTreeVal(hash, key,
52 value)) != null) {
53 oldVal = p.val;
54 if (!onlyIfAbsent)
55 p.val = value;
56 }
57 }
58 }
59 }
60 if (binCount != 0) {
61 if (binCount >= TREEIFY_THRESHOLD)
62 treeifyBin(tab, i);
63 if (oldVal != null)
64 return oldVal;
65 break;
66 }
67 }
68 }
69 //扩容
70 addCount(1L, binCount);
71 return null;
72 }