ArrayList原始碼詳解
阿新 • • 發佈：2021-11-10
目錄
1 ArrayList原始碼
工作中經常聽到別人講容器，各種各樣的容器，話說到底什麼是容器，通俗的講容器就是用來裝東西的器皿，比如：水桶就是用來盛水的，水桶就是一個容器
在我們寫程式的時候常常要對大量的物件進行管理，比如查詢，遍歷，修改等。jdk為我們提供的容器位於java.util包，也是我們平時用的最多的包之一。
但是為什麼不用陣列（其實也不是不用，只是不直接用）呢，因為陣列的長度需要提前確定，而且不能改變大小，用起來手腳受限嘛。
下面步入正題，首先一個物件管理容器需要哪些功能？增加，刪除，修改，查詢（crud對不對？）還有呢？遍歷，容量，是否包含某個元素。。。
功能是有了，如果讓你自己實現一個這樣的容器該怎麼實現呢？
看看ArrayList是怎麼實現這些功能的。
1.1 ArrayList定義
首先先來看下頂級介面Collection的定義，
public interface Collection<E> extends Iterable<E> { int size(); boolean isEmpty(); boolean contains(Object o); Iterator<E> iterator(); Object[] toArray(); <T> T[] toArray(T[] a); boolean add(E e); boolean remove(Object o); boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean equals(Object o); int hashCode(); }
然後是介面List的定義，
public interface List<E> extends Collection<E> { int size(); boolean isEmpty(); boolean contains(Object o); Iterator<E> iterator(); Object[] toArray(); <T> T[] toArray(T[] a); boolean add(E e); boolean remove(Object o); boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean addAll( int index, Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean equals(Object o); int hashCode(); E get( int index); E set( int index, E element); void add( int index, E element); E remove( int index); int indexOf(Object o); int lastIndexOf(Object o); ListIterator<E> listIterator(); ListIterator<E> listIterator( int index); List<E> subList( int fromIndex, int toIndex); }
再看下ArrayList的定義
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
可以看出ArrayList繼承AbstractList（這是一個抽象類，對一些基礎的list操作進行封裝），實現List，RandomAccess，Cloneable，Serializable幾個介面，RandomAccess是一個標記介面，用來表明其支援快速隨機訪問。
1.2 底層儲存
ArrayList就是用陣列實現的List容器，既然是用陣列實現，當然底層用陣列來儲存資料啦。。。
private transient Object[] elementData;
private int size;
可以看到用一個Object陣列來儲存資料，用一個int值來計數，記錄當前容器的資料大小。
另外，細心的人會發現elementData陣列是使用transient修飾的，關於transient關鍵字的作用簡單說就是java自帶預設機制進行序列化的時候，被其修飾的屬性不需要維持。會不會產生一點疑問？elementData不需要維持，那麼怎麼進行反序列化，又怎麼保證序列化和反序列化資料的正確性？難道不需要儲存？既然需要儲存，它是怎麼實現的呢？
預設序列化機制，ArrayList一定是使用了自定義的序列化方式，到底是不是這樣的呢？看下面兩個方法：
/** * Save the state of the <tt>ArrayList</tt> instance to a stream (that
* is, serialize it).
*
* @serialData The length of the array backing the <tt>ArrayList </tt>
* instance is emitted (int), followed by all of its elements
* (each an <tt>Object</tt> ) in the proper order.
*/ private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff12 int expectedModCount = modCount ;
s.defaultWriteObject();
// Write out array length16 s.writeInt( elementData.length );
// Write out all elements in the proper order.19 for (int i=0; i<size; i++)
s.writeObject( elementData[i]);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
/** * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
* deserialize it).
*/ private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff35 s.defaultReadObject();
// Read in array length and allocate array38 int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];
// Read in all elements in the proper order.42 for (int i=0; i<size; i++)
a[i] = s.readObject();
}
英語註釋很詳細，也很容易讀懂，就不進行翻譯了。那麼想一下為什麼要這樣設計呢，豈不是很麻煩。下面簡單進行解釋下：
elementData 是一個數據儲存陣列，而陣列是定長的，它會初始化一個容量，等容量不足時再擴充容量（擴容方式為資料拷貝，後面會詳細解釋），再通俗一點說就是比如elementData 的長度是10，而裡面只儲存了3個物件，那麼陣列中其餘的7個元素（null）是沒有意義的，所以也就不需要儲存，以節省序列化後的記憶體容量，好了到這裡就明白了這樣設計的初衷和好處，順便好像也明白了長度單獨用一個int變數儲存，而不是直接使用elementData.length的原因。
1.3 構造方法
/** * 構造一個具有指定容量的list
*/ public ArrayList( int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException( "Illegal Capacity: " +
initialCapacity);
this.elementData = new Object[initialCapacity];
}
/** * 構造一個初始容量為10的list
*/ public ArrayList() {
this(10);
}
/** * 構造一個包含指定元素的list，這些元素的是按照Collection的迭代器返回的順序排列的
*/ public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData .length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)26 if (elementData .getClass() != Object[].class)
elementData = Arrays.copyOf( elementData, size , Object[].class);
}
構造方法看完了，想一下指定容量的構造方法的意義，既然預設為10就可以那麼為什麼還要提供一個可以指定容量大小的構造方法呢
1.4 增加
/** * 新增一個元素
*/
public boolean add(E e) {
// 進行擴容檢查 ensureCapacity( size + 1); // Increments modCount
// 將e增加至list的資料尾部，容量+1 8 elementData[size ++] = e;
return true;
}
/** * 在指定位置新增一個元素
*/ public void add(int index, E element) {
// 判斷索引是否越界，這裡會丟擲多麼熟悉的異常。。。
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: " +size);
// 進行擴容檢查
ensureCapacity( size+1); // Increments modCount
// 對陣列進行復制處理，目的就是空出index的位置插入element，並將index後的元素位移一個位置
System. arraycopy(elementData, index, elementData, index + 1,
size - index);
// 將指定的index位置賦值為element
elementData[index] = element;
// list容量+1
size++;
}
/** * 增加一個集合元素
*/
public boolean addAll(Collection<? extends E> c) {
//將c轉換為陣列
Object[] a = c.toArray();
int numNew = a.length ;
//擴容檢查
ensureCapacity( size + numNew); // Increments modCount
//將c新增至list的資料尾部
System. arraycopy(a, 0, elementData, size, numNew);
//更新當前容器大小
size += numNew;
return numNew != 0;
}
/** * 在指定位置，增加一個集合元素
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length ;
ensureCapacity( size + numNew); // Increments modCount
// 計算需要移動的長度（index之後的元素個數）
int numMoved = size - index;
// 陣列複製，空出第index到index+numNum的位置，即將陣列index後的元素向右移動numNum個位置
if (numMoved > 0)
System. arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 將要插入的集合元素複製到陣列空出的位置中66 System. arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
/** * 陣列容量檢查，不夠時則進行擴容
*/
public void ensureCapacity( int minCapacity) {
modCount++;
// 當前陣列的長度77
int oldCapacity = elementData .length;
// 最小需要的容量大於當前陣列的長度則進行擴容
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
// 新擴容的陣列長度為舊容量的1.5倍+1
int newCapacity = (oldCapacity * 3)/2 + 1;
// 如果新擴容的陣列長度還是比最小需要的容量小，則以最小需要的容量為長度進行擴容
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
// 進行資料拷貝，Arrays.copyOf底層實現是System.arrayCopy()
elementData = Arrays.copyOf( elementData, newCapacity);
}
}
1.5 刪除
/** * 根據索引位置刪除元素
*/
public E remove( int index) {
// 陣列越界檢查
RangeCheck(index);
modCount++;
// 取出要刪除位置的元素，供返回使用
E oldValue = (E) elementData[index];
// 計算陣列要複製的數量
int numMoved = size - index - 1;
// 陣列複製，就是將index之後的元素往前移動一個位置
if (numMoved > 0)
System. arraycopy(elementData, index+1, elementData, index,
numMoved);
// 將陣列最後一個元素置空（因為刪除了一個元素，然後index後面的元素都向前移動了，所以最後一個就沒用了），好讓gc儘快回收
// 不要忘了size減一
elementData[--size ] = null; // Let gc do its work
return oldValue;
}
/** * 根據元素內容刪除，只刪除匹配的第一個
*/
public boolean remove(Object o) {
// 對要刪除的元素進行null判斷
// 對資料元素進行遍歷查詢，知道找到第一個要刪除的元素，刪除後進行返回，如果要刪除的元素正好是最後一個那就慘了，時間複雜度可達O(n) 。。。
if (o == null) {
for (int index = 0; index < size; index++)
// null值要用==比較
if (elementData [index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
// 非null當然是用equals比較了
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++;
// 原理和之前的add一樣，還是進行陣列複製，將index後的元素向前移動一個位置，不細解釋了，
int numMoved = size - index - 1;
if (numMoved > 0)
System. arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size ] = null; // Let gc do its work60 }
/** * 陣列越界檢查
*/
private void RangeCheck(int index) {
if (index >= size )
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: " +size);
}
看到了這個方法，便可jdk原始碼有些地方寫的也不是那麼精巧，比如這裡remove時將陣列越界檢查封裝成了一個單獨方法，可是往前翻一下add方法中的陣列越界就沒有進行封裝，需要檢查的時候都是寫一遍一樣的程式碼
增加和刪除方法到這裡就解釋完了，程式碼是很簡單，主要需要特別關心的就兩個地方：1.陣列擴容，2.陣列複製，這兩個操作都是極費效率的，最慘的情況下(新增到list第一個位置，刪除list最後一個元素或刪除list第一個索引位置的元素)時間複雜度可達O(n)
為什麼提供一個可以指定容量大小的構造方法？看到這裡是不是有點明白了呢，簡單解釋下：如果陣列初試容量過小，假設預設的10個大小，而我們使用ArrayList的主要操作時增加元素，不斷的增加，一直增加，不停的增加，會出現上面後果？那就是陣列容量不斷的受挑釁，陣列需要不斷的進行擴容，擴容的過程就是陣列拷貝System.arraycopy的過程，每一次擴容就會開闢一塊新的記憶體空間和資料的複製移動，這樣勢必對效能造成影響。那麼在這種以寫為主（寫會擴容，刪不會縮容）場景下，提前預知性的設定一個大容量，便可減少擴容的次數，提高了效能。
上面兩張圖分別是陣列擴容和陣列複製的過程，需要注意的是，陣列擴容伴隨著開闢新建的記憶體空間以建立新陣列然後進行資料複製，而陣列複製不需要開闢新記憶體空間，只需將資料進行復制。
上面講增加元素可能會進行擴容，而刪除元素卻不會進行縮容，如果在已刪除為主的場景下使用list，一直不停的刪除而很少進行增加，那麼會出現什麼情況？再或者陣列進行一次大擴容後，我們後續只使用了幾個空間，會出現什麼情況？空間浪費
/** * 將底層陣列的容量調整為當前實際元素的大小，來釋放空間。
*/
public void trimToSize() {
modCount++;
// 當前陣列的容量
int oldCapacity = elementData .length;
// 如果當前實際元素大小 小於 當前陣列的容量，則進行縮容
if (size < oldCapacity) {
elementData = Arrays.copyOf( elementData, size );
}
1.6 更新
/** * 將指定位置的元素更新為新元素
*/
public E set( int index, E element) {
// 陣列越界檢查
RangeCheck(index);
// 取出要更新位置的元素，供返回使用
E oldValue = (E) elementData[index];
// 將該位置賦值為行的元素
elementData[index] = element;
// 返回舊元素
return oldValue;
}
1.7 查詢
/** * 查詢指定位置上的元素
*/
public E get( int index) {
RangeCheck(index);
return (E) elementData [index];
}
由於ArrayList使用陣列實現，更新和查詢直接基於下標操作，變得十分簡單。
1.8 是否包含
/** * 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 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;
}
/**
* Returns the index of the last occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the highest 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 lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData [i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData [i]))
return i;
}
return -1;
}
contains主要是檢查indexOf，也就是元素在list中出現的索引位置也就是陣列下標，再看indexOf和lastIndexOf程式碼，和public boolean remove(Object o) 的程式碼一樣，都是元素null判斷，都是迴圈比較，但是要知道，最差的情況（要找的元素是最後一個）也是很慘的。。。
1.9 容量判斷
/**
* Returns the number of elements in this list.
*
* @return the number of elements in this list
*/
public int size() {
return size ;
}
/**
* 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;
}
由於使用了size進行計數，發現list大小獲取和判斷好容易