為了有針對性的準備面試，鎖屏面試題百日百刷開始每日從各處收集的面經中選擇幾道經典面試題分享並給出答案供參考，答案中會做與題目相關的擴充套件，並且可能會丟擲一定問題供思考。這些題目我會標註具體的公司、招聘型別(校招、社招、實習)以及面試階段。下面是今日面試題:
====ArrayList 和 LinkedList 實現原理和前者的擴容機制？[阿里雲][校招][一面]
以下內容均是以jdk1.8來講:
ArrayList實現原理:
Arraylist底層是用一個Object陣列elementData來儲存資料的:
transient Object[] elementData; // non-private to simplify nested class access
從建立一個ArrayList開始看，一般都是通過new即通過建構函式來建立一個ArrayList看原始碼:
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
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);
}
}
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,以及用另一個ArrayList初始化新的ArrayList的建構函式。
再看ArrayList的操作:
1)新增:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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);
}
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);
}
這裡，modCount是我們每次對ArrayList做改變大小的時候會做一次自增操作的變數，記錄下修改次數。核心的常問的一個方法就是這個grow()方法，這是當ArrayList中元素的陣列(上面講到的儲存資料的)elementData容量不夠時做的擴容操作。這裡我們以用空參構造器建立ArrayList時，第一次向ArrayList新增元素時會做一次擴容操作來講:
判斷容量是否足夠的就是這麼一句:if (minCapacity - elementData.length > 0)
在grow中，核心的一段就是int newCapacity = oldCapacity + (oldCapacity >> 1);新的容量是舊的容量的1.5倍(oldCapacity >> 1實際上是一次oldCapacity除2操作)
注意這裡擴容觸發條件是在使用無參構造器第一次新增元素，以及新增元素時，判斷髮現陣列長度不夠時。
2) 刪除：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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);
}
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);
}
看程式碼很簡單，就是做一次陣列複製，移動要刪除的某一位置元素的後面的元素，並且將舊陣列置為null做垃圾回收。指定remove(Object O)這個方法也是先找對應元素的下標，然後做與上面程式碼差不多的操作。有興趣的可以看下原始碼。
查詢就沒啥好講的了，底層是陣列儲存，查詢很容易做到。可自行看原始碼。
LinkedList實現原理:
LinkedList儲存是通過雙向連結串列實現的:
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(Collection<? extends E> c)也是著重體現在新增元素的操作，所以直接講它的一些操作，這裡需要大家能夠懂連結串列的增刪改查的操作，因為LinkedList的這些操作就是根據這些來的。希望大家能夠找一下資料瞭解下，這裡篇幅有限，不作講解。
1) 新增：
頭部新增:
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
看下上面關於LinkedList一開始講的，可以看到LinkedList成員變數就有儲存first和last，這裡從頭部插入和從尾部插入基本上操作一致，只是儲存位置不同，看程式碼很容易看懂，就是對連結串列的操作，至於add()方法是在尾部插入新的元素。
2) 刪除
removeFirst()和removeLast()以及remove()(remove和removeFirst()操作一致)，都是簡單去連結串列表頭或表尾的操作，可以自己看原始碼，熟悉連結串列操作的同學很容易就能看懂，不作贅述。說一說remove(int index)：
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
Node<E> node(int index) {
// assert isElementIndex(index);
// 這裡是做了一個加速查詢的操作
// 獲取index處的節點。
// 若index < 雙向連結串列長度的1/2,則從前先後查詢;
// 否則，從後向前查詢。
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;
}
}
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) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
這裡是先根據index找到LinkedList中儲存的節點，見上圖node()方法，然後開始刪除元素操作，見unlink()方法，熟悉連結串列的刪除操作，很容易能看懂，判斷刪除的元素是否是表頭後表尾，是的話簡單的賦值一下即可，不是的話做相應的刪除操作。Remove(Object o)這個方法也是先找到這個list中是否有這個元素，先通過查詢，再呼叫unlink()方法刪除。
3）查詢
LinkedList查詢操作在上面的刪除操作中，先查詢在做刪除的步驟中已經講過(上面的node方法)，請自行對照原始碼檢視查詢操作。