一、背景（罗素悖论）
一天，村里的理发师挂出了一个牌子 “村里所有不给自己理发的人，都由我来理发，我也只给这些人理发” 有人问理发师：你自己的头发谁来理？
罗素：英国哲学家、数学家，1902年提出，撼动了数学界的基石。 集合论：现代数学的基石，数学家康托尔，德国人，有着犹太的血统。 开始是研究三角函数，逐渐摸索并提出了集合论，引来巨大的争议， 包括他的老师，逐渐抑郁，以致精神失常，落寞地病逝于精神病院。
当前最聪明的三大人种：犹太人、日耳曼人、亚裔人(中国人) 电影《美丽心灵》 博弈论的提出者 纳什 的个人传记，一生都于精神分裂 抗争，最终获得诺贝尔经济学奖。
二、集合这些事儿(三大块)
List 有顺序可重复的 ArrayList Set 无顺序不可重复的 HashSet Map 键值对 key-value HashMap
三、ArrayList
如果存储渡一所有的成员，用什么？ 100 - 1000 - 10000 (容器：动态的，快速查询)
1）概述 (60分)
array 数组（本质） list列表 数组：int[] arr = new int[3] 初始化需要定义长度，且长度不能更改 动态数组：arraylist解决数组长度固化的问题，同时带来新的问题。 判断容量不足时，进行扩容，扩容算法？
数组的特性：内存空间是连续存储的，随机访问的效率非常之高。
封装为arraylist后，增加和删除的效率就降低了。
增加时，可能需要扩容；删除时，可能需要移动
面试题：
a arraylist是如何扩容的？ b 如果要加入1w条数据，如何提高效率？ (80分) c 它是线程安全的吗？如何做到线程安全？ d fail_fast是什么？ (100分
2）源码分析（1.8版本）
a 类声明
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
i 继承了AbstractList并实现List , 需要提供最基本的增删改查功能 ii 实现了RandomAccess，支持随机访问/快速访问，和数组的访问方式一致 iii 实现了Cloneable，能够被克隆 iv 实现了Serializable，可以被序列化，如果需要自定义序列化，需要实现writeObject和readObject方法
b 构造器 (alt+7 查看方法列表)
i 无参 //存储所有数据的对象数组
Object[] elementData
public ArrayList() {
//初始化时，赋值一个空的数组 {}
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ii 有参int类型 //传入初始化容量
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);
}
}
iii 有参集合类型 //记录数组实际包含的元素数量 int size; // 支持将其他集合转为arraylist
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
// 判断获取的数组是否是object[]类型
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
c 增加元素
//赋值并且将size+1
public boolean add(E e) {
//确认容量是否足够
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//先计算容量 然后确认精确的容量
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 默认的初始化容量
int DEFAULT_CAPACITY = 10;
//对于空数组至少需要有1个容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 返回默认容量(10)和最小容量(1)的最大值
//第一次扩容的时候，至少扩容到10
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//记录更改的次数
int modCount = 0;
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//扩容的核心操作
grow(minCapacity);
}
// elementData是{} minCapacity是10
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// " >> 1 " 右移==/2
// 新容量是旧容量的1.5倍 why？
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
//最小值校验 当前赋值10
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);
}
扩容算法： i 最小扩容范围是10 ii 默认扩容范围是旧容量的1.5倍
验证性能： 如果数据量很大，并且逐个add的时候，需要扩容多少次？ 1k 1w 10w 100w 分别是多少？ 12 18 23 29 优秀的算法 能够减少扩容次数
3)、删除元素
支持两种方式：索引、对象本身
//以索引删除为例
public E remove(int index) {
//范围检查
rangeCheck(index);
//更改次数+1
modCount++;
E oldValue = elementData(index);
// 计算要移动的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
//通过拷贝的方式 移动元素
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//把最后一位元素置为空 size-1
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
4)、遍历元素
在foreach循环中不能移除元素，会报同步修改异常 ConcurrentModificationException
fast-fail机制 (快速失败) 线程不安全 本质上，是在可能发生故障的时候，快速提醒，快速处理。
5)、线程安全
Vector类是线程安全，过时了，加了一堆锁，效率低极了
CopyOnWriteArrayList 在concurrent包下 原理：把增删的操作通过新的复制来实现，然后改变array的引用。 (降低效率)
