Java Collection筆記之ArrayList
1、前言
ArrayList 是一個數組隊列，相當於動態數組。與Java中的數組相比，它的容量能動態增長。它繼承於AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable這些接口。
ArrayList 繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。
ArrayList實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，爲List提供快速訪問功能的。在ArrayList中，我們即可以通過元素的序號快速獲取元素對象；這就是快速隨機訪問。
ArrayList 實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。
- ArrayList 實現java.io.Serializable接口，這意味着ArrayList支持序列化，能通過序列化去傳輸。
簡單地來說，ArrayList是對數組進行快速操作的一系列API。
ArrayList中的操作不是線程安全的。所以，建議在單線程中才使用ArrayList，而在多線程中可以選擇Vector或者CopyOnWriteArrayList。
2、簡單使用
ArrayList<Integer> list = new ArrayList<Integer>();
for(int i=0;i< 10; i++ ){
//給數組增加10個Int元素
list.add(i);
}
System.out.println("數組是否包含3："+list.contains(3));
System.out.println("數組元素的數量："+list.size());
System.out.println("數組的第三個元素："+list.get(3));
//移除第三個元素
list.remove(3);
System.out.println("數組是否包含23："+list.contains(3));
System.out.println("數組元素的數量："+list.size());
System.out.println("數組的第三個元素："+list.get(3));
list.clear();
System.out.println("數組元素的數量："+list.size());
結果：
數組是否包含3：true
數組元素的數量：10
數組的第三個元素：3
數組是否包含23：false
數組元素的數量：9
數組的第三個元素：4
數組元素的數量：0
3、源碼簡單分析
3.1 構造方法
ArrayList的構造方法有3個。
前面說到ArrayList是對數組進行快速操作的一系列API。而ArrayList的構造方法就是對這個默認數組elementData的初始化。
- 默認的構造方法，併爲內置的elementData初始化一個DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空數組。
/** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/** * Constructs an empty list with an initial capacity of ten. */
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
- 第二個構造方法是通過定義長度，爲內置的elementData初始化，長度爲initialCapacity，長度不能爲負數。
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @throws IllegalArgumentException if the specified initial capacity * is negative */
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);
}
}
- 根據另外一個數據集合，爲內置的elementData初始化，把集合中的數據拷貝到elementData中。
/** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */
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 {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
3.2 增加元素
爲數據增加元素的方法有四個：
- 將指定的元素添加到此列表的尾部。
/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
代碼比較簡單，就是先調用ensureCapacityInternal，通過Arrays類的copyOf方法把舊數組拷貝到一個長度比舊數組大1的新數組中去（其實我們看來就是舊數組的長度加1，但我們都知道數組不是變長的，所有隻能使用拷貝創建新數組的方式來實現變長的功能），然後再把新的元素添加到數組最後一個位置。
當然，我們看到grow方法中，可能不是把數組的容量增大。舊數組的長度和新數組的長度是一樣的，數組本身尾部的一些位置都是空閒的，因爲ArrayList作了移除元素的操作。
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/** * The maximum size of array to allocate. * Some VMs reserve some header words in an array. * Attempts to allocate larger arrays may result in * OutOfMemoryError: Requested array size exceeds VM limit */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/** * Increases the capacity to ensure that it can hold at least the * number of elements specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
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:
elementData = Arrays.copyOf(elementData, newCapacity);
}
- 將指定的元素插入此列表中的指定位置。
/** * Inserts the specified element at the specified position in this * list. Shifts the element currently at that position (if any) and * any subsequent elements to the right (adds one to their indices). * * @param index index at which the specified element is to be inserted * @param element element to be inserted * @throws IndexOutOfBoundsException {@inheritDoc} */
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
首先判斷index位置的合法性：
private void rangeCheckForAdd(int index) {
if (index < 0 || index > this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
然後和前一個方法一樣，在ensureCapacityInternal方法裏面，使用數組的長度加1。
這裏再通過System.arraycopy對數組再一次進行拷貝。與Arrays.copyOf不同的是，System.arraycopy只是把index位置及其後面的元素，拷貝到數組的index+1及其後面的位置中，也就是把index及其後面的元素全部後移一位。
最後，把新的元素放到數組的index位置。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
參數
src -- 這是源數組.
srcPos -- 這是源數組中的起始位置。
dest -- 這是目標數組。
destPos -- 這是目標數據中的起始位置。
length -- 這是一個要複製的數組元素的數目。
- 按照指定集合的迭代器所返回的元素順序，將該集合中的所有元素添加到此列表的尾部。
/**
* Appends all of the elements in the specified collection to the end of
* this list, in the order that they are returned by the
* specified collection's Iterator. The behavior of this operation is
* undefined if the specified collection is modified while the operation
* is in progress. (This implies that the behavior of this call is
* undefined if the specified collection is this list, and this
* list is nonempty.)
*
* @param c collection containing elements to be added to this list
* @return <tt>true</tt> if this list changed as a result of the call
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
理解了前面兩個方法後，這個方法就比較容易了。先獲取增加進來的集合的數量numNew，使用數組的長度加numNew ，再通過System.arraycopy把集合中所以的元素增加到數組後面的位置中。
- 從指定的位置開始，將指定集合中的所有元素插入到此列表中。
/** * Inserts all of the elements in the specified collection into this * list, starting at the specified position. Shifts the element * currently at that position (if any) and any subsequent elements to * the right (increases their indices). The new elements will appear * in the list in the order that they are returned by the * specified collection's iterator. * * @param index index at which to insert the first element from the * specified collection * @param c collection containing elements to be added to this list * @return <tt>true</tt> if this list changed as a result of the call * @throws IndexOutOfBoundsException {@inheritDoc} * @throws NullPointerException if the specified collection is null */
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
和前面那些方法基本原理是一樣的，只是過程中需要判斷插入的位置，如果插入的位置剛好在原數組的尾部，那我們直接添加到後面就好。如果不在尾部，那就把原數組index位置及後面的元素，通過System.arraycopy，往後移numNew位，再把集合中的元素添加到index及後面的位置即可。
注意：所有增加元素的方法中，都會使ArrayList的size屬性發生變化。
3.3 替換元素
用指定的元素替代此列表中指定位置上的元素。
/** * Replaces the element at the specified position in this list with * the specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
很簡單，先通過rangeCheck判斷index這個位置是否是合法的。然後把新的元素放到index位置，返回舊元素。
private void rangeCheck(int index) {
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
3.4 移除元素
移除元素的方法有6個：
- 移除此列表中指定位置上的元素。
/** * Removes the element at the specified position in this list. * Shifts any subsequent elements to the left (subtracts one from their * indices). * * @param index the index of the element to be removed * @return the element that was removed from the list * @throws IndexOutOfBoundsException {@inheritDoc} */
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] = null; // clear to let GC do its work
return oldValue;
}
在判斷index的合法性後，判斷index的位置，如果index是最後一個元素，直接把此位置的元素位置設置爲空。如果不是，則把這個元素之後的元素都往前移一位，然後把最後一個位置設置爲空。
- 移除此列表中首次出現的指定元素（如果存在）。
/**
* Removes the first occurrence of the specified element from this list,
* if it is present. If the list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index
* <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>
* (if such an element exists). Returns <tt>true</tt> if this list
* contained the specified element (or equivalently, if this list
* changed as a result of the call).
*
* @param o element to be removed from this list, if present
* @return <tt>true</tt> if this list contained the specified element
*/
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
/*
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
在這個移除方法中，最要是爲了找出要移除元素出現的第一個位置（假如存在）。然後再使用fastRemove將這個位置的元素移除掉。
這裏的fastRemove(int index)方法與前面的remove(int index)基本相同，只是少了檢查index的合法性及返回值而已。
- 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。
/**
* Removes from this list all of the elements whose index is between
* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
* Shifts any succeeding elements to the left (reduces their index).
* This call shortens the list by {@code (toIndex - fromIndex)} elements.
* (If {@code toIndex==fromIndex}, this operation has no effect.)
*
* @throws IndexOutOfBoundsException if {@code fromIndex} or
* {@code toIndex} is out of range
* ({@code fromIndex < 0 ||
* fromIndex >= size() ||
* toIndex > size() ||
* toIndex < fromIndex})
*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
這裏很簡單，把toIndex位置及其後的元素，移到fromIndex及其後面的位置上，再後面的位置全部清空。
- 移除此列表中包含着指定集合裏的元素（如果存在）
/**
* Removes from this list all of its elements that are contained in the
* specified collection.
*
* @param c collection containing elements to be removed from this list
* @return {@code true} if this list changed as a result of the call
* @throws ClassCastException if the class of an element of this list
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this list contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see Collection#contains(Object)
*/
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
- 移除此列表中除指定集合裏的元素之外的元素
/**
* Retains only the elements in this list that are contained in the
* specified collection. In other words, removes from this list all
* of its elements that are not contained in the specified collection.
*
* @param c collection containing elements to be retained in this list
* @return {@code true} if this list changed as a result of the call
* @throws ClassCastException if the class of an element of this list
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this list contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see Collection#contains(Object)
*/
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
上面兩個方法都很簡單，都是先判斷集合參數是否爲空，然後調用batchRemove來作數據的移除。
batchRemove方法的complement參數用於判斷是保留集合元素或刪除集合元素。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
- 移除此列表中的所有元素。
/** * Removes all of the elements from this list. The list will * be empty after this call returns. */
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
這方法就更簡單了，就是把數組所有位置都設置爲空。
注意：所有移除元素的方法中，都會使ArrayList的size屬性發生變化。
3.5 獲取元素
獲取ArrayList元素的方法也有兩種：
- 返回此列表中指定位置上的元素。
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
/** * Returns the element at the specified position in this list. * * @param index index of the element to return * @return the element at the specified position in this list * @throws IndexOutOfBoundsException {@inheritDoc} */
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
檢查完index的合法性後，直接根據index座標返回內置數組位置的元素。
- 通過Iterator接口實現來獲取元素。
這種方式常用於列表元素的遍歷。
/** * Returns an iterator over the elements in this list in proper sequence. * * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>. * * @return an iterator over the elements in this list in proper sequence */
public Iterator<E> iterator() {
return new Itr();
}
iterator方法會創建一個Iterator接口實現對象。
ArrrayList內置的Iterator接口實現(如下)，是通過遊標cursor的方式來確定列表的訪問的當前位置，然後通過cursor作爲數組下標來獲取或者移除列表元素。
/** * An optimized version of AbstractList.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 boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/** * An optimized version of AbstractList.ListItr */
private 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;
}
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
3.6 其它方法
- 返回此列表中首次出現的指定元素的索引
/**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
如果沒有提定元素則返回-1。
- 如果此列表中包含指定的元素
/**
* Returns <tt>true</tt> if this list contains the specified element.
* More formally, returns <tt>true</tt> if and only if this list contains
* at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this list is to be tested
* @return <tt>true</tt> if this list contains the specified element
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
如果找得到此列表中首次出現的指定元素的索引，說明是包含指定元素。
- 返回此列表中的元素數。
/** * Returns the number of elements in this list. * * @return the number of elements in this list */
public int size() {
return size;
}
我們在前面增加和移除列表元素的時候都會使用size發生變化。ArrayList是通過size來記錄元素的個數的。
爲什麼我們不是返回內置數組elementData的長度呢？很明顯，ArrayList做移除操作的時候，只是把最後位置設置爲空，則不是把長度減短。
- 列表中是否有元素
/** * Returns <tt>true</tt> if this list contains no elements. * * @return <tt>true</tt> if this list contains no elements */
public boolean isEmpty() {
return size == 0;
}
3.7 關於RandomAccess接口
List 實現所使用的標記接口，用來表明其支持快速（通常是固定時間）隨機訪問。此接口的主要目的是允許一般的算法更改其行爲，從而在將其應用到隨機或連續訪問列表時能提供良好的性能。
將操作隨機訪問列表的最佳算法（如 ArrayList）應用到連續訪問列表（如 LinkedList）時，可產生二次項的行爲。如果將某個算法應用到連續訪問列表，那麼在應用可能提供較差性能的算法前，鼓勵使用一般的列表算法檢查給定列表是否爲此接口的一個 instanceof，如果需要保證可接受的性能，還可以更改其行爲。
現在已經認識到，隨機和連續訪問之間的區別通常是模糊的。例如，如果列表很大時，某些 List 實現提供漸進的線性訪問時間，但實際上是固定的訪問時間。這樣的 List 實現通常應該實現此接口。實際經驗證明，如果是下列情況，則 List 實現應該實現此接口，即對於典型的類實例而言，此循環：
for (int i=0, n=list.size(); i < n; i++)
list.get(i);
的運行速度要快於以下循環：
for (Iterator i=list.iterator(); i.hasNext(); )
i.next();
如通過Collection.shuffle()隨機打亂一個順序數組,JDK判斷如果集合屬於RandomAccess，則通過簡單的for循環遍歷數組，而不屬於RandomAccess的話，則使用ListIterator來遍歷。
/** * Randomly permute the specified list using the specified source of * randomness. All permutations occur with equal likelihood * assuming that the source of randomness is fair.<p> * * This implementation traverses the list backwards, from the last element * up to the second, repeatedly swapping a randomly selected element into * the "current position". Elements are randomly selected from the * portion of the list that runs from the first element to the current * position, inclusive.<p> * * This method runs in linear time. If the specified list does not * implement the {@link RandomAccess} interface and is large, this * implementation dumps the specified list into an array before shuffling * it, and dumps the shuffled array back into the list. This avoids the * quadratic behavior that would result from shuffling a "sequential * access" list in place. * * @param list the list to be shuffled. * @param rnd the source of randomness to use to shuffle the list. * @throws UnsupportedOperationException if the specified list or its * list-iterator does not support the <tt>set</tt> operation. */
@SuppressWarnings({"rawtypes", "unchecked"})
public static void shuffle(List<?> list, Random rnd) {
int size = list.size();
if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
for (int i=size; i>1; i--)
swap(list, i-1, rnd.nextInt(i));
} else {
Object arr[] = list.toArray();
// Shuffle array
for (int i=size; i>1; i--)
swap(arr, i-1, rnd.nextInt(i));
// Dump array back into list
// instead of using a raw type here, it's possible to capture
// the wildcard but it will require a call to a supplementary
// private method
ListIterator it = list.listIterator();
for (int i=0; i<arr.length; i++) {
it.next();
it.set(arr[i]);
}
}
}
關於這個訪問速度的問題，可以參考：http://blog.csdn.net/keda8997110/article/details/8635005
4、說明
- Vector的整個實現與ArrayList基本相似，只是在對一些操作性的方法上加上了synchronized關鍵字，使之在線程上是安全的。
- 本文中源碼大部分來源於JDK1.8。