Collection
public interface Collection<E> extends Iterable<E>- Collection实现子类可以存放多个元素，每个元素可以是Object
- 有些Collection的实现类可以存放重复的元素，有些不可以
- 有些Collection的实现类，有些是有序的，有些不是有序的
- Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
- Collection接口遍历元素方式1，使用Iterator（迭代器）
- Iterator对象成为迭代器，主要用于遍历Collection集合中的元素
- 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
- Iterator仅用于遍历集合，Iterator本身不存放对象（快捷键itit）
在调用iterator.next()方法之前必须调用iterator.hasNext()进行检测。若不调用且下一条记录无效，直接调用it.next()会抛出异常
增强for循环可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样，只能用于遍历集合或数组。（快捷键大写I）
List接口
- List接口是Collection接口的子接口 List.java
- List集合中的每个元素都有对应的顺序索引，即支持索引
- List集合中的每个元素都有其对应的顺序索引，即支持索引
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
ArrayList
- 可以加入null，并且多个
- 是由数组来实现数据存储的
- ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高），多线程下不建议使用ArrayList
源码分析：
ArrayList中维护了一个Object类型的数组elementData。transient Object[] elementData（transient 表示瞬间，短暂的，该属性不会被序列化）
- 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}public boolean add(E e) {
//确认大小够不够我添加一个数据，先确定是否要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//然后再执行赋值操作
elementData[size++] = e;
return true;
}private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}//该方法确定minCapacity
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//如果elementData是{}
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 1 和 默认10 找一个最大值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//第二次添加时，elementData不是{}，直接返回
return minCapacity;
}private void ensureExplicitCapacity(int minCapacity) {
//记录当前集合修改次数，防止有多个线程来修改它
modCount++;
// overflow-conscious code
//当前最小容量 - 实际数组大小大于0. 10 - 0 > 0
//第二次添加，2 - 10 < 0，不进行扩容
if (minCapacity - elementData.length > 0)
//如果elementData的大小不够就扩容
grow(minCapacity);
}private void grow(int minCapacity) {
// overflow-conscious code
//第一次是0
//第二次扩容10
int oldCapacity = elementData.length;
//第一次是0
//第二次扩容15
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:
//第一次扩容是十个null，使用扩容机制来确定要扩容到多大
elementData = Arrays.copyOf(elementData, newCapacity);
}- 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍
比如初始化为8容量的数组，如果加到第9个就扩容为12
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);
}
}Vector
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.SerializableVector底层也是一个对象数组
protected Object[] elementData;Vector是线程同步的，即线程安全的，Vector类的操作方法带有synchronized，在开发中需要线程同步安全时，考虑使用Vector
public Vector() {
this(10);
}public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//扩容两倍 有参构造可以指定capacityIncrement
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}LinkedList
- 底层实现了双向链表和双端队列特点
- 可以添加任意元素（元素可以重复），包括null
- 线程不安全，没有实现同步
public LinkedList() {
}此时LinkedList的属性first = null last = null
public boolean add(E e) {
linkLast(e);
return true;
}Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}