各大公司的Java面試都會考到一些java源碼的問題,這個系列我將一一爲大家剖析
各種java重要的源碼
ArrayList與LinkedList是經常會進行比較的2個類,因爲他們都實現了List類
本質上講,他們底層存儲方式是不一樣的
private transient Object[] elementData;
這個是ArrayList的底層存儲方式,是一個對象數組
而LinkedList底層是什麼呢?
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的一個內部類,也是它的存儲方式,其實LinkedList的存儲方式就是一個雙向鏈表
所以下面所說的區別,其實也就是數據結構是順序存儲結構和鏈式存儲結構的區別
先看添加,add方法
ArrayList:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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++;
}
ArrayList重載的這2種add方法,其中都調用了ensureCapacityInternal(size + 1);這個方法一直查看調用,會發現這個方法其實
就是新創建一個長度爲size+1的數組,然後將現在數組的值拷貝上去,如果是add(E e),拷貝完成後將e放到最後即可,如果是
add(int index, E element),則需要再進行一次拷貝,建index以及之後的元素後移一位,然後再講元素放到index位置即完成,補充
一句這裏的拷貝都是native層實現。
LinkedList:
public boolean add(E e) {
linkLast(e);
return true;
}
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
可以看到當添加到末尾的時候都調用了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++;
}
其實就是新建一個Node然後放到最後,如果不是添加到末尾的時候先調用node(index)方法找到那個節點
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;
}
}
這裏的查找也做了一定的優化,判斷這個節點是離頭近還是離尾近,然後調用linkBefore方法插入
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)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
再看刪除,remove方法
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;
}
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;
}
如果要按照索引刪除,先copy(刪除索引位置元素,並調整後面元素位置),然後將最後一個元素置空,方便GC回收
modCount++;是因爲modCount是記錄這個ArrayList對象的修改次數
如果要按照元素刪除的話,其實是先找到索引然後調用fastRemove()
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
}
這個方法其實和按照索引刪除基本一樣,只不過少了個索引的越界檢查,因爲這個是查找到的
LinkedList:
public E remove() {
return removeFirst();
}
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
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;
}
如果是直接刪除,調用removeFirst方法
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
LinkedList默認是刪除第一個元素
如果是按照索引刪除,先運用node()找到這個元素,前面已經介紹過了,然後調用unlink()方法,
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;
}
如果是按照元素刪除,則是先找到那個元素,然後還是調用unlink()方法
總結:1.總體來看ArrayList和LinkedList的add和remove方法,LinkedList要更加簡單一點,效率也更快,原因還
是因爲,存儲結構的不同
2.還有就是會發現一個我們沒有見過的屬性modCount,記錄修改次數,這個屬性有什麼用呢,後邊慢慢給大家講
3.對了,補充一點,查看繼承關係,會發現,ArrayList是繼承了AbstractList,AbstractList才實現了List,而
LinkedList是直接實現了List,所以LinkedList可以說是ArrayList的叔叔
下一篇將詳細解析ArrayList和LinkedList的查詢和修改