所有集合基于jdk1.8，对源码稍做调整。
ArrayList
主要变量
//默认容量
private final int DEFAULT_CAPACITY = 10;
//默认元素
private final Object[] EMPTY_ELEMENTDATE = {};
//元素
transient Object[] elementData;
//大小
private int size;
构造方法
public ArrayList(int initialCapacity) {
if(initialCapacity > 0){
this.elementData = new Object[initialCapacity];
}else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATE;
}else {
throw new IllegalArgumentException("初始容量错误:" + initialCapacity);
}
}
public ArrayList() {
this.elementData = EMPTY_ELEMENTDATE;
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if((size = elementData.length) != 0){
if(elementData.getClass() != Object[].class){
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
}else{
this.elementData = EMPTY_ELEMENTDATE;
}
}
第一个可以传入一个初始容量initialCapacity，ArrayList就会创建一个长度为initialCapacity的数据。
第二个直接将创建一个0长度数组。
第三个可以传入集合框架，要求泛型是该ArrayLIst泛型本身或其子类。
主要方法
add
public boolean add(E e) {
ensureCapacity(size + 1);
//实际赋值
elementData[size++] = e;
return true;
}
private void ensureCapacity(int capacity) {
//元素为空数组，容量取最小为10
if(elementData == EMPTY_ELEMENTDATE){
capacity = Math.max(capacity, DEFAULT_CAPACITY);
}
//当所需容量大于当前数组长度时，扩容
if(capacity > elementData.length){
int oldCapacity = elementData.length;
//扩容1.5倍
int newCapacity = oldCapacity + oldCapacity >> 1;
//扩容后还是小于所设容量，将所设容量设为新容量
if(newCapacity < capacity){
newCapacity = capacity;
}
//当扩容后大于数组最大大小
else if (newCapacity > MAX_ARRAY_SIZE) {
newCapacity = capacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
get
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
/**
* 范围check，数组越界则抛出异常
* @param index
*/
private void rangeCheck(int index) {
if(index >= size || index < 0){
throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
}
}
/**
* 统一解除警告
* @return
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
Vector
Vector结构和ArrayList相似，提供了四个构造函数。多提供的构造函数为:
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
第二个参数用于指定长度不够时扩容多少，当该值小于等于0时，Vector扩容2倍。而ArrayList是扩容1.5倍。
主要方法
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
方法前面都加了关键字synchronized，所有Vector是线程安全的，但是效率低。
Stack
Stack继承Vector，只提供了一个构造函数。
主要方法
public E push(E item) {
addElement(item);
return item;
}
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
push用于添加一个元素，pop删除并返回最后一个元素。
