ArrayList和LinkList的源碼分析
概要
ArrayList和LinkList是常用的存儲結構,不看源碼先分析字面意思,Array意思是數組,可知其底層是用數組實現的,Link意思是鏈接,可知是以鏈表實現,這兩種數據結構各有什么特點呢?在實際開發中,我們要如何選擇?
1.ArrayList
- ArrayList是實現了List接口的可變數組,即動態數組,它不僅實現了List的可選操作,同時允許元素為null,它提供了一些方法來操作數組的大小來保存元素,該類大致相當於Vector,只是ArrayList不是線程安全的.
- 每個ArrayList實例都有一個容量capacity,它是存儲元素的數組的大小,其值至少等於list的size,當元素添加到ArrayList中,它的capacity會自動增大.
- 注意ArrayList的實現是非線程安全的,如果多個線程同時訪問ArrayList實例,且至少有一個線程修改了元素,那么必須要加鎖synchronized.
- 下面是ArrayList的類關系圖,可以看出其繼承了AbstractList,實現了List, RandomAccess, Cloneable, java.io.Serializable接口.
1.1基本屬性
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ private static final long serialVersionUID = 8683452581122892189L; /** * 默認初始容量10 */ private static final int DEFAULT_CAPACITY = 10; /** * 空實例的空數組 */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * 默認空實例的空數組 */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * 存儲元素的數組,它的大小就是ArrayList的容量,不用序列化 */ transient Object[] elementData; // non-private to simplify nested class access /** * ArrayList元素的大小 */ private int size; }
1.2構造器
/** * 構造空的list,並指定初始容量 * * @param initialCapacity 初始容量 * @throws IllegalArgumentException 如果初始容量為負數 */ 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); } } /** * 構造空的list,並指定初始容量10 */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } /** * 構造list,包含指定集合的所有元素 * * @param c 指定的集合 * @throws NullPointerException 如果指定集合為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; } }
ArrayList list = new ArrayList(),默認容量為10,如果添加超過10個元素,就會造成list的擴容,內部會創建一個新的數組,對效率會有影響,如果有大量的元素添加,那么list就會頻繁擴容,效率低下.因此在開發中可以指定初始容量,細節之中可以看出一個人的基本功.
1.3常用方法
/** * 返回list元素的數量 */ public int size() { return size; } /** * 判斷list是否包含元素,返回true或false */ public boolean isEmpty() { return size == 0; } /** * 判斷是夠包含指定的元素,返回true或false */ public boolean contains(Object o) { return indexOf(o) >= 0; } /** * 返回元素第一次出現的索引index * 如果list沒有這個元素,返回-1,否則返回第一次出現的index * 注意:也可以查詢null的索引 */ 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; } /** * 返回元素最后一次出現的索引index * 如果list沒有這個元素,返回-1,否則返回最后一次出現的index * 注意:也可以查詢null的索引 */ 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; } /** * 返回指定索引的元素 * @param index 索引 * @return 元素 * @throws IndexOutOfBoundsException, 如果index超出數組的范圍 */ public E get(int index) { rangeCheck(index); return elementData(index); } /** * 替換指定索引的元素 * * @param index 索引 * @param element 新元素 * @return 老元素 * @throws IndexOutOfBoundsException */ public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; }
下面重點介紹add()和remove()方法,元素的新增和刪除內部是如何實現的呢?
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
ArrayList新增元素時,也就是在list的尾部添加一個元素,首先修改元素的數量+1
ensureCapacityInternal(size+1),即list的size+1,元素數量加1,詳細實現如下:
private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }
元素的數量+1后,判斷minCapacity有沒有超出當前的容量,如果超出了,就要進行擴容操作grow()
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); }
其邏輯如下:新容量 = 老容量 + 老容量右移1位(即除以2),也就是大約1.5倍的老容量,為什么說大約呢?因為如果老容量是偶數,那么新容量正好等於1.5倍老容量,如果老容量是奇數11,那么新容量是15.
容量在大,也是有限制的,最大MAX_ARRAYSIZE = Integer.MAXVALUE - 8,有21億,估計沒有人會放這么多的數據吧.elementData[size++] = e, 然后把新元素e放在新索引的位置,也就是數組的尾部.
ArrayList刪除元素有兩種,一種是根據索引刪除,二是直接刪除對象
-
根據索引刪除對象
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; }
舉個例子, 有個List包含4個元素A,B,C,D, 現在要刪除index=2 的元素C,那么是怎么執行的?
流程圖如下:
numMoved = 4 - 2- 1 = 1;
System.arraycopy(elementData, 3, elementData, 2,1);
本質上是把要刪除的元素替換為它后面的元素,然后把最后一個元素賦值為null,手動GC,返回老的元素.
-
直接刪除對象
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; }
就是循環遍歷數組,當元素第一次出現的時候,刪除這個元素,同時返回true,如果元素不存在,那么數組不改變,同時返回false.
2.LinkList
- LinkList是List接口的雙向鏈表實現,不僅實現了List的方法,同時允許元素為null
- 獲取index索引的元素時,會從鏈表的頭部或尾部進行查找,哪邊近從哪邊開始
- 注意該實現是線程非安全
下面是LinkList的類關系圖,它繼承了AbstractSequentialList,實現了List, Deque, Cloneable, java.io.Serializable接口
2.1基本屬性
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{ transient int size = 0; /** * 第一個節點,不用序列化 */ transient Node<E> first; /** * 最后一個節點,不用序列化 */ transient Node<E> last; }
2.2構造器
/** * 構造空的list */ public LinkedList() { } /** * 構造指定集合的list * @param c 集合 * @throws NullPointerException 如果集合為null */ public LinkedList(Collection<? extends E> c) { this(); addAll(c); }
2.3常用方法
添加元素add()
/** * 在LinkList的尾部添加元素 * 這個方法相當於addLast * 返回true/false */ public boolean add(E e) { linkLast(e); return true; }
linkLast的具體實現如下:
void linkLast(E e) { //l賦值為last節點 final Node<E> l = last; //創建新的節點e,前面元素是l,后面是null final Node<E> newNode = new Node<>(l, e, null); //把新的節點標記為last節點 last = newNode; //判斷是不是第一個節點 //如果是,新的節點就是第一個節點 if (l == null) first = newNode; else //如果不是,之前的最后一個節點后面是新的節點 l.next = newNode; size++; modCount++; }
刪除元素remove()
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; }
從頭部遍歷所有的節點,如果當前節點元素與要刪除的節點元素相同,那么移除當前節點,如果LinkList包含多個要刪除的元素,那么只會刪除index較小的那個節點.
3.總結
- ArrayList實現了RandomAccess,隨機讀取數據速度較快,它有索引index,會直接讀取數組的索引,效率很高,但是新增和刪除元素,內部進行數組的動態復制,效率低，如果遇到大量的數據add操作，頻繁擴容，性能更差
- LinkList新增元素就是創建了一個新的節點,只要把last節點指向最后一個元素即可,效率很高,刪除元素,就是移除指定的節點,同時調整前后的節點即可,但是對於隨機訪問元素,它需要判斷當前index離頭部和尾部哪個更近,然后去依次查找,效率低下
- 所以對於隨機快速讀取數據,可以使用ArrayList,對於快速新增和刪除元素,可以使用LinkList