ArrayList、LinkedList和Vector源碼分析 ArrayList ArrayList是一個底層使用數組來存儲對象，但不是線程安全的集合類 ArrayList的類結構關係 ArrayList實現了List介面，List介面中定義了一些對列表通過下標進行添加刪除等方法 ArrayLis ...
ArrayList、LinkedList和Vector源碼分析
ArrayList
ArrayList是一個底層使用數組來存儲對象，但不是線程安全的集合類
ArrayList的類結構關係
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
}
ArrayList實現了List介面，List介面中定義了一些對列表通過下標進行添加刪除等方法
ArrayList實現了RandomAccess介面，這個介面是一個標記介面，介面中並沒有任何的方法，ArrayList底層是用數組來存儲對象，當然是能夠通過下標隨機訪問的，實現了RandomAccess介面的類在查詢時的速度會很快但是添加刪除元素慢，而LinkedList是通過鏈表的方式實現的，它沒有實現RandomAccess介面，在查詢時慢但是增加刪除的速度快
所以在使用集合遍歷大量數據時，可以先用instanceof來判斷集合是不是實現了RandomAccess
public void test1() {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
if(list instanceof RandomAccess) {//RandomAccess實現類，使用下標訪問
for(int i=0;i<list.size();i++) {
//todo
}
}else {//不是RandomAccess實現類，使用iterator遍歷
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()) {
//todo
}
}
}
ArrayList實現了Cloneable介面,所以可以合法調用clone方法，如果沒有實現Cloneable介面，那麼會拋出CloneNotSupporteddException，詳見
ArrayList實現了Serializable介面，可以將對象序列化，用於傳輸或持久化，詳見
屬性
//序列化Id
private static final long serialVersionUID = 8683452581122892189L;
//預設初始化大小
private static final int DEFAULT_CAPACITY = 10;
//空數組對象，用於有參構造且初始化大小為0時
private static final Object[] EMPTY_ELEMENTDATA = {};
//空數組對象，用於無參構造時，這兩個屬性主要用來區分創建ArrayList時有沒有指定容量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//保存對象的容器，使用transient修飾即在序列化時，不進行序列化，這是因為ArrayList添加了序列化方法private void writeObject(java.io.ObjectOutputStream s)只把保存的數據序列化了，而不是把整個數組序列化，提高效率
transient Object[] elementData;
//保存的對象個數
private int size;
//最大容量2的31次方減9
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
構造器
ArrayList提供了三個構造器，一個是指定初始化大小的構造器，一個人無參預設初始化大小構造器，一個是使用集合初始化的構造器
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//數組的大小為指定大小
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//大小為0用一個共用的空數組賦值
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList() {
//用共用的空數組賦值，不使用EMPTY_ELEMENTDATA主要是區分是使用的哪個構造器
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 集合為空，使用空數組
this.elementData = 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));
}
//計算容量
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);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//新容量=老容量+老容量>>1;老容量>>1即老容量無符號右移1位，即除以2，所以最後新容量是老容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)//新容量比最小容量小那麼把最小容量賦值給新容量
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//如果minCapacity很大，計算得出newCapacity超出最大容量
newCapacity = hugeCapacity(minCapacity);
// 複製未擴容之前的數據
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//如果最小容量還超出ArrayList規定的最大值那麼數組大小為Integer.MAX_VALUE否則為ArrayList規定的最大值
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
在指定位置添加元素
public void add(int index, E element) {
//檢查添加元素的下標
rangeCheckForAdd(index);
//檢查容量，進行擴容
ensureCapacityInternal(size + 1); // Increments modCount!!
// public static native void arraycopy(src, srcPos,dest, destPos,length);
//src：源數組；srcPos：源數組起始下標；dest：目標數組；destPos：目標數組起始下標；length：拷貝長度
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
//元素的下標必須為0-size
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
移除元素
按照下標移除元素
public E remove(int index) {
//檢查下標
rangeCheck(index);
modCount++;
//按照下標獲取元素
E oldValue = elementData(index);
//計算需要移動的數據個數
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//清理數組elementData[size]位置的元素
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
private void rangeCheck(int index) {
//下標必須在0到size-1之間
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
按值移除元素
public boolean remove(Object o) {
if (o == null) {//如果移除的元素為null,依次遍歷保存的元素，移除第一個為null的元素
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//移除
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
//使用equals判斷是否相等
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
modCount++;
//計算移除後需要移動的元素個數
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//清理數組elementData[size]位置的元素
elementData[--size] = null; // clear to let GC do its work
}
modCount
ArrayList在進行add、set、remove時，都進行了modCount+1操作，這個屬性與fast fail有關，當對象創建Iterator對象時會把modCount賦值給expectedModCount，當使用Iterator進行遍歷時，如果發現對象的modCount與expectedModCount不相等，會直接拋出ConcurrentModificationException異常
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
...
public E next() {
checkForComodification();
...
}
final void checkForComodification() {
if (modCount != expectedModCount)//直接拋出異常
throw new ConcurrentModificationException();
}
出現情況：當Iterator遍歷時，如果對象的modCount和expectedModCount不等就會拋出異常，主要有這些情況
- 使用iterator遍歷時，進行了add、remove等破壞結構的操作
- 多線程環境下，一個線程在遍歷時，另一個線程進行了add、remove等破壞結構的操作
通過源碼學習，我發現set方法並沒有增加modCount,為什麼呢？難道一個線程在使用iterator遍歷，另外一個線程改變了一個位置的元素，Iterator不用拋出異常？有知道的請賜教！
LinkedList
LinkedList類結構
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList繼承AbstractSequentialList可以實現通過Iterator的隨機訪問
LinkedList實現List介面可以進行添加刪除等操作
LinkedList實現了DeQue,允許在隊列的兩端進行入隊和出隊，所以可以把LinkedList當做隊列或棧使用
LinkedList實現了Cloneable，可以通過clone快速克隆對象
LinkedList實現了Serializable介面，可以將LinkedList序列化，進行流操作
構造器
public LinkedList() {
}
//使用集合初始化鏈表
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
屬性
//鏈表的大小，transient表明在序列化的時候不進行序列化，但是LinkedList自定義的序列化方法中進行了序列化
transient int size = 0;
//鏈表的頭節點
transient Node<E> first;
//鏈表的尾節點
transient Node<E> last;
節點
private static class Node<E> {
E item;
//前驅
Node<E> next;
//後繼
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
可以看到LinkedList是一個雙向鏈表
方法
Deque是一個雙端鏈表，即鏈表可有當做棧和隊列使用
getFirst方法,相當於Queue中的element方法,如果隊空，就拋出異常
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
getLast方法
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
removeFirst方法，相當於Queue的remove方法，刪除隊頭元素，如果隊空，拋出異常
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
//如果原頭節點的後繼為空，那麼把尾指針也更新為空
last = null;
else
//原頭節點的後繼為不空，那麼需要把它的前驅更新為空
next.prev = null;
//更新鏈表大小
size--;
modCount++;
return element;
}
removeLast方法，如果隊空，拋出異常
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
//如果原尾指針的前驅為空，那麼頭指針指向也為空
first = null;
else
//原尾指針的前驅不為空，那麼它的後繼應該改為空
prev.next = null;
size--;
modCount++;
return element;
}
addFirst方法，相當於Statck中的push方法
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
//創建一個前驅為空，後驅為first的新節點
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
//如果原頭指針為空，那麼把尾指針也賦值為新加節點
last = newNode;
else
//原頭指正不空，把它的前驅更新為新節點
f.prev = newNode;
size++;
modCount++;
}
addLast方法,相當於Queue中的add方法
public void addLast(E e) {
linkLast(e);
}
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++;
}
add方法是重寫AbstractList中的方法，即往List中添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
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++;
}
remove方法移除鏈表中指定元素
public boolean remove(Object o) {
if (o == null) {
//如果要移除的對象為null,那麼取鏈表中找第一個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)) {//使用equals比較兩個對象是否相同
unlink(x);
return true;
}
}
}
return false;
}
addAll方法向鏈表中添加指定集合的元素
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
//如果集合大小為0
if (numNew == 0)
return false;
//什麼一個前驅節點和一個後繼節點
Node<E> pred, succ;
if (index == size) {
//如果添加的位置恰好是size即在鏈表最後添加,那麼後繼為null，前驅為鏈表尾指針
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)//如果沒有前驅節點
//把鏈表頭指針指向新節點
first = newNode;
else
pred.next = newNode;
//前驅節點賦值為當前新節點
pred = newNode;
}
if (succ == null) {//如果沒有後繼節點
//把尾指針指向'前驅節點'
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
clear方法清空鏈表，但是modCount並不會清空
public void clear() {
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
//help GC？
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
get方法獲取指定下標元素，非法下標拋出異常
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
// assert isElementIndex(index);
//通過一個二分遍歷拿元素
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
set方法設置指定下標元素值，非法下標拋出異常，set方法modCount不++？why？
public E set(int index, E element) {
checkElementIndex(index);
//獲取元素
Node<E> x = node(index);
E oldVal = x.item;
//替換
x.item = element;
return oldVal;
}
add方法，指定下標添加元素，非法下標拋出異常
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)//鏈表尾添加元素
linkLast(element);
else
//鏈表中間位置添加元素
linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)//添加元素位置前驅為null，即添加位置本來就是頭指針位置
first = newNode;
else
//更新前驅的next為當前添加節點
pred.next = newNode;
size++;
modCount++;
}
remove方法，移除指定下標元素，非法下標拋出異常
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
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) {//如果移除節點的前驅為null，即移除節點為頭指針指向位置
first = next;
} else {
prev.next = next;
//help GC？
x.prev = null;
}
if (next == null) {//如果移除節點的後繼節點為null，即移除節點是尾指針指向位置
last = prev;
} else {
next.prev = prev;
//help GC？
x.next = null;
}
//help GC？
x.item = null;
size--;
modCount++;
return element;
}
peek方法，獲取鏈表頭節點，可為Queue/Stack方法，Queue方法即獲取隊手元素，Stack方法即獲取棧頂元素
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
element方法，獲取鏈表頭節點，與peek方法不同的是，如果隊列為空，拋出異常
public E element() {
return getFirst();
}
public E getFirst() {
final Node<E> f = first;
if (f == null)
//鏈表空拋出異常
throw new NoSuchElementException();
return f.item;
}
poll方法移除鏈表頭節點，鏈表空返回null
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
remove方法移除鏈表頭節點，鏈表空拋出異常
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
//鏈表空拋出異常
throw new NoSuchElementException();
return unlinkFirst(f);
}
offer方法，在鏈表尾添加元素
public boolean offer(E e) {
return add(e);
}
public boolean add(E e) {
linkLast(e);
return true;
}
offerFirst方法，在鏈表頭添加節點，對應棧的入棧操作
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public void addFirst(E e) {
linkFirst(e);
}
offerLast方法，在鏈表尾添加元素，本質上和offer方法沒有區別
public boolean offerLast(E e) {
addLast(e);
return true;
}
public void addLast(E e) {
linkLast(e);
}
peekFirst方法，查看鏈表頭節點，相當於Queue和Stack的peek方法，鏈表空返回null
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
peekLast方法，查看鏈表尾節點，鏈表空返回null
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
pollFirst方法，查看並刪除鏈表頭節點，鏈表空返回null
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
pollLast查看並刪除鏈表尾節點，鏈表空返回null
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
push方法頭節點位置添加，Stack的push方法
public void push(E e) {
addFirst(e);
}
public void addFirst(E e) {
linkFirst(e);
}
pop方法刪除頭節點位置元素,Stack的pop方法
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)//鏈表空拋異常
throw new NoSuchElementException();
return unlinkFirst(f);
}
removeFirstOccurrence方法從頭結點開始查找指定元素並移除
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
public boolean remove(Object o) {
if (o == null) {//要移除的元素為null
for (Node<E> x = first; x != null; x = x.next) {//從頭查找，移除第一個為null元素
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {//依次遍歷
if (o.equals(x.item)) {//使用equals判斷相等
unlink(x);
return true;
}
}
}
return false;
}
removeLastOccurrence方法從尾節點開始查找並移除指定元素
public boolean removeLastOccurrence(Object o) {
if (o == null) {//如果移除元素為null
for (Node<E> x = last; x != null; x = x.prev) {//從後往前遍歷
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {//使用equals判斷相等
unlink(x);
return true;
}
}
}
return false;
}
listIterator方法返回鏈表迭代器
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
//由於LinkedList是雙向鏈表，所以可以雙向遍歷
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
//expectedModCount保存拿到迭代器時，LinkedList的modCount值，與快速失敗有關
private int expectedModCount = modCount;
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
final void checkForComodification() {
if (modCount != expectedModCount)//如果鏈表的modCount和拿到迭代器時modCount不同，說明在迭代過程中，鏈表進行了破壞結構的修改，那麼應該直接拋出異常
throw new ConcurrentModificationException();
}
}
Vector
類結構
可以看到，Vector的類結構和ArrayList的一模一樣
Vector繼承AbstractList實現了List介面
Vector實現了RandomAccess介面，可以隨機訪問
Vector實現了Cloneable介面，可以使用克隆對象
Vector實現了Serializable介面，可以序列化
屬性
//保存對象的數組
protected Object[] elementData;
//保存元素個數
protected int elementCount;
//增長因數
protected int capacityIncrement;
//定義的最大容量，為2的31次方-9
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
構造器
public Vector(int initialCapacity, int capacityIncrement) {//指定初始容量和增長因數
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//直接把數組創建為初始化值大小
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
public Vector(int initialCapacity) {
//把增長因數設置為0
this(initialCapacity, 0);
}
public Vector() {
//預設初始化大小為10
this(10);
}
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
方法
線程安全的方法
copyInto方法把元素拷貝到指定數組
public synchronized void copyInto(Object[] anArray) {
System.arraycopy(elementData, 0, anArray, 0, elementCount);
}
trimToSize方法把保存元素的數組修改到保存元素個數大小
public synchronized void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {//如果元素個數比容量小
elementData = Arrays.copyOf(elementData, elementCount);
}
}
ensureCapacity方法用於添加元素時，確保數組大小
public synchronized void ensureCapacity(int minCapacity) {
if (minCapacity > 0) {
modCount++;
ensureCapacityHelper(minCapacity);
}
}
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;
//如果指定了增長因數而且增長因數>0那麼新容量就等於原容量+增長因數，否則就是原容量的二倍
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);
}
setSize方法設置向量的大小
public synchronized void setSize(int newSize) {
modCount++;
if (newSize > elementCount) {//如果新容量比原容量大，多的元素全為null
ensureCapacityHelper(newSize);
} else {
//新容量比原容量小
for (int i = newSize ; i < elementCount ; i++) {
elementData[i] = null;
}
}
elementCount = newSize;
}
removeElementAt移除指定位置元素
public synchronized void removeElementAt(int index) {
modCount++;
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
//要移動的元素個數
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}
insertElementAt指定位置插入元素
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
//確保容量
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}
addElement在尾部添加元素
public synchronized void addElement(E obj) {
modCount++;
//確保容量
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}
removeElement移除指定元素
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
removeAllElements移除所有元素
public synchronized void removeAllElements() {
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;
elementCount = 0;
}
get獲取指定位置元素
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
set替換指定位置元素
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
add方法添加元素，與addElement方法的區別僅僅是返回值不同
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
remove移除尾元素
public boolean remove(Object o) {
return removeElement(o);
}
add指定位置添加元素
public void add(int index, E element) {
insertElementAt(element, index);
}
remove移除指定位置元素
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
//計算要移動的元素個數
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}
listIterator獲取向量的迭代器，可以進行向前向後遍歷
public synchronized ListIterator<E> listIterator() {
return new ListItr(0);
}
final class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public E previous() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
cursor = i;
return elementData(lastRet = i);
}
}
public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.set(lastRet, e);
}
}
public void add(E e) {
int i = cursor;
synchronized (Vector.this) {
checkForComodification();
Vector.this.add(i, e);
expectedModCount = modCount;
}
cursor = i + 1;
lastRet = -1;
}
}
可以看到Vector和ArrayList的源碼基本相同，只是Vector是線程安全的，還有就是Vector和ArrayList在擴容上有一點點不同，Vector如果指定了增長因數，那麼新容量是原容量+增長因數，而ArrayList是擴大1.5倍原容量
