Java中LinkedList詳解和使用示例_動(dòng)力節(jié)點(diǎn)Java學(xué)院整理
更新時(shí)間：2017年05月12日 09:51:15 投稿：mrr
LinkedList 是一個(gè)繼承于AbstractSequentialList的雙向鏈表。它也可以被當(dāng)作堆棧、隊(duì)列或雙端隊(duì)列進(jìn)行操作。接下來通過示例代碼給大家詳細(xì)介紹java中l(wèi)inkedlist的使用，需要的朋友參考下吧
第1部分 LinkedList介紹
LinkedList簡介
LinkedList 是一個(gè)繼承于AbstractSequentialList的雙向鏈表。它也可以被當(dāng)作堆棧、隊(duì)列或雙端隊(duì)列進(jìn)行操作。
LinkedList 實(shí)現(xiàn) List 接口，能對它進(jìn)行隊(duì)列操作。
LinkedList 實(shí)現(xiàn) Deque 接口，即能將LinkedList當(dāng)作雙端隊(duì)列使用。
LinkedList 實(shí)現(xiàn)了Cloneable接口，即覆蓋了函數(shù)clone()，能克隆。
LinkedList 實(shí)現(xiàn)java.io.Serializable接口，這意味著LinkedList支持序列化，能通過序列化去傳輸。
LinkedList 是非同步的。
LinkedList構(gòu)造函數(shù)
// 默認(rèn)構(gòu)造函數(shù) LinkedList() // 創(chuàng)建一個(gè)LinkedList，保護(hù)Collection中的全部元素。 LinkedList(Collection<? extends E> collection)
LinkedList的API
LinkedList的API boolean add(E object) void add(int location, E object) boolean addAll(Collection<? extends E> collection) boolean addAll(int location, Collection<? extends E> collection) void addFirst(E object) void addLast(E object) void clear() Object clone() boolean contains(Object object) Iterator<E> descendingIterator() E element() E get(int location) E getFirst() E getLast() int indexOf(Object object) int lastIndexOf(Object object) ListIterator<E> listIterator(int location) boolean offer(E o) boolean offerFirst(E e) boolean offerLast(E e) E peek() E peekFirst() E peekLast() E poll() E pollFirst() E pollLast() E pop() void push(E e) E remove() E remove(int location) boolean remove(Object object) E removeFirst() boolean removeFirstOccurrence(Object o) E removeLast() boolean removeLastOccurrence(Object o) E set(int location, E object) int size() <T> T[] toArray(T[] contents) Object[] toArray()
AbstractSequentialList簡介
在介紹LinkedList的源碼之前，先介紹一下AbstractSequentialList。畢竟，LinkedList是AbstractSequentialList的子類。
AbstractSequentialList 實(shí)現(xiàn)了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)這些函數(shù)。這些接口都是隨機(jī)訪問List的，LinkedList是雙向鏈表；既然它繼承于AbstractSequentialList，就相當(dāng)于已經(jīng)實(shí)現(xiàn)了“get(int index)這些接口”。
此外，我們?nèi)粜枰ㄟ^AbstractSequentialList自己實(shí)現(xiàn)一個(gè)列表，只需要擴(kuò)展此類，并提供 listIterator() 和 size() 方法的實(shí)現(xiàn)即可。若要實(shí)現(xiàn)不可修改的列表，則需要實(shí)現(xiàn)列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。
第2部分 LinkedList數(shù)據(jù)結(jié)構(gòu)
LinkedList的繼承關(guān)系
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}
LinkedList與Collection關(guān)系如下圖：
LinkedList的本質(zhì)是雙向鏈表。
(01) LinkedList繼承于AbstractSequentialList，并且實(shí)現(xiàn)了Dequeue接口。
(02) LinkedList包含兩個(gè)重要的成員：header 和 size。
header是雙向鏈表的表頭，它是雙向鏈表節(jié)點(diǎn)所對應(yīng)的類Entry的實(shí)例。Entry中包含成員變量： previous, next, element。其中，previous是該節(jié)點(diǎn)的上一個(gè)節(jié)點(diǎn)，next是該節(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)，element是該節(jié)點(diǎn)所包含的值。
size是雙向鏈表中節(jié)點(diǎn)的個(gè)數(shù)。
第3部分 LinkedList源碼解析(基于JDK1.6.0_45)
為了更了解LinkedList的原理，下面對LinkedList源碼代碼作出分析。
在閱讀源碼之前，我們先對LinkedList的整體實(shí)現(xiàn)進(jìn)行大致說明：
LinkedList實(shí)際上是通過雙向鏈表去實(shí)現(xiàn)的。既然是雙向鏈表，那么它的順序訪問會(huì)非常高效，而隨機(jī)訪問效率比較低。
既然LinkedList是通過雙向鏈表的，但是它也實(shí)現(xiàn)了List接口{也就是說，它實(shí)現(xiàn)了get(int location)、remove(int location)等“根據(jù)索引值來獲取、刪除節(jié)點(diǎn)的函數(shù)”}。LinkedList是如何實(shí)現(xiàn)List的這些接口的，如何將“雙向鏈表和索引值聯(lián)系起來的”？
實(shí)際原理非常簡單，它就是通過一個(gè)計(jì)數(shù)索引值來實(shí)現(xiàn)的。例如，當(dāng)我們調(diào)用get(int location)時(shí)，首先會(huì)比較“l(fā)ocation”和“雙向鏈表長度的1/2”；若前者大，則從鏈表頭開始往后查找，直到location位置；否則，從鏈表末尾開始先前查找，直到location位置。
這就是“雙線鏈表和索引值聯(lián)系起來”的方法。
好了，接下來開始閱讀源碼(只要理解雙向鏈表，那么LinkedList的源碼很容易理解的)。
package java.util;
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 鏈表的表頭，表頭不包含任何數(shù)據(jù)。Entry是個(gè)鏈表類數(shù)據(jù)結(jié)構(gòu)。
private transient Entry<E> header = new Entry<E>(null, null, null);
// LinkedList中元素個(gè)數(shù)
private transient int size = 0;
// 默認(rèn)構(gòu)造函數(shù)：創(chuàng)建一個(gè)空的鏈表
public LinkedList() {
header.next = header.previous = header;
}
// 包含“集合”的構(gòu)造函數(shù):創(chuàng)建一個(gè)包含“集合”的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 獲取LinkedList的第一個(gè)元素
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
// 鏈表的表頭header中不包含數(shù)據(jù)。
// 這里返回header所指下一個(gè)節(jié)點(diǎn)所包含的數(shù)據(jù)。
return header.next.element;
}
// 獲取LinkedList的最后一個(gè)元素
public E getLast() {
if (size==0)
throw new NoSuchElementException();
// 由于LinkedList是雙向鏈表；而表頭header不包含數(shù)據(jù)。
// 因而，這里返回表頭header的前一個(gè)節(jié)點(diǎn)所包含的數(shù)據(jù)。
return header.previous.element;
}
// 刪除LinkedList的第一個(gè)元素
public E removeFirst() {
return remove(header.next);
}
// 刪除LinkedList的最后一個(gè)元素
public E removeLast() {
return remove(header.previous);
}
// 將元素添加到LinkedList的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
// 將元素添加到LinkedList的結(jié)束位置
public void addLast(E e) {
addBefore(e, header);
}
// 判斷LinkedList是否包含元素(o)
public boolean contains(Object o) {
return indexOf(o) != -1;
}
// 返回LinkedList的大小
public int size() {
return size;
}
// 將元素(E)添加到LinkedList中
public boolean add(E e) {
// 將節(jié)點(diǎn)(節(jié)點(diǎn)數(shù)據(jù)是e)添加到表頭(header)之前。
// 即，將節(jié)點(diǎn)添加到雙向鏈表的末端。
addBefore(e, header);
return true;
}
// 從LinkedList中刪除元素(o)
// 從鏈表開始查找，如存在元素(o)則刪除該元素并返回true；
// 否則，返回false。
public boolean remove(Object o) {
if (o==null) {
// 若o為null的刪除情況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
// 若o不為null的刪除情況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 將“集合(c)”添加到LinkedList中。
// 實(shí)際上，是從雙向鏈表的末尾開始，將“集合(c)”添加到雙向鏈表中。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
// 從雙向鏈表的index開始，將“集合(c)”添加到雙向鏈表中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
// 獲取集合的長度
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
// 設(shè)置“當(dāng)前要插入節(jié)點(diǎn)的后一個(gè)節(jié)點(diǎn)”
Entry<E> successor = (index==size ? header : entry(index));
// 設(shè)置“當(dāng)前要插入節(jié)點(diǎn)的前一個(gè)節(jié)點(diǎn)”
Entry<E> predecessor = successor.previous;
// 將集合(c)全部插入雙向鏈表中
for (int i=; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
// 調(diào)整LinkedList的實(shí)際大小
size += numNew;
return true;
}
// 清空雙向鏈表
public void clear() {
Entry<E> e = header.next;
// 從表頭開始，逐個(gè)向后遍歷；對遍歷到的節(jié)點(diǎn)執(zhí)行一下操作：
// () 設(shè)置前一個(gè)節(jié)點(diǎn)為null
// () 設(shè)置當(dāng)前節(jié)點(diǎn)的內(nèi)容為null
// () 設(shè)置后一個(gè)節(jié)點(diǎn)為“新的當(dāng)前節(jié)點(diǎn)”
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
// 設(shè)置大小為0
size = 0;
modCount++;
}
// 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
}
// 設(shè)置index位置對應(yīng)的節(jié)點(diǎn)的值為element
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
// 在index前添加節(jié)點(diǎn)，且節(jié)點(diǎn)的值為element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
// 刪除index位置的節(jié)點(diǎn)
public E remove(int index) {
return remove(entry(index));
}
// 獲取雙向鏈表中指定位置的節(jié)點(diǎn)
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
// 獲取index處的節(jié)點(diǎn)。
// 若index < 雙向鏈表長度的1/2,則從前先后查找;
// 否則，從后向前查找。
if (index < (size >> 1)) {
for (int i = ; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
// 從前向后查找，返回“值為對象(o)的節(jié)點(diǎn)對應(yīng)的索引”
// 不存在就返回-1
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
// 從后向前查找，返回“值為對象(o)的節(jié)點(diǎn)對應(yīng)的索引”
// 不存在就返回-1
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
// 返回第一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為0,則返回null
public E peek() {
if (size==)
return null;
return getFirst();
}
// 返回第一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為0,則拋出異常
public E element() {
return getFirst();
}
// 刪除并返回第一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為,則返回null
public E poll() {
if (size==0)
return null;
return removeFirst();
}
// 將e添加雙向鏈表末尾
public boolean offer(E e) {
return add(e);
}
// 將e添加雙向鏈表開頭
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
// 將e添加雙向鏈表末尾
public boolean offerLast(E e) {
addLast(e);
return true;
}
// 返回第一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為,則返回null
public E peekFirst() {
if (size==)
return null;
return getFirst();
}
// 返回最后一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為,則返回null
public E peekLast() {
if (size==)
return null;
return getLast();
}
// 刪除并返回第一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為,則返回null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
// 刪除并返回最后一個(gè)節(jié)點(diǎn)
// 若LinkedList的大小為0,則返回null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
// 將e插入到雙向鏈表開頭
public void push(E e) {
addFirst(e);
}
// 刪除并返回第一個(gè)節(jié)點(diǎn)
public E pop() {
return removeFirst();
}
// 從LinkedList開始向后查找，刪除第一個(gè)值為元素(o)的節(jié)點(diǎn)
// 從鏈表開始查找，如存在節(jié)點(diǎn)的值為元素(o)的節(jié)點(diǎn)，則刪除該節(jié)點(diǎn)
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 從LinkedList末尾向前查找，刪除第一個(gè)值為元素(o)的節(jié)點(diǎn)
// 從鏈表開始查找，如存在節(jié)點(diǎn)的值為元素(o)的節(jié)點(diǎn)，則刪除該節(jié)點(diǎn)
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 返回“index到末尾的全部節(jié)點(diǎn)”對應(yīng)的ListIterator對象(List迭代器)
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
// List迭代器
private class ListItr implements ListIterator<E> {
// 上一次返回的節(jié)點(diǎn)
private Entry<E> lastReturned = header;
// 下一個(gè)節(jié)點(diǎn)
private Entry<E> next;
// 下一個(gè)節(jié)點(diǎn)對應(yīng)的索引值
private int nextIndex;
// 期望的改變計(jì)數(shù)。用來實(shí)現(xiàn)fail-fast機(jī)制。
private int expectedModCount = modCount;
// 構(gòu)造函數(shù)。
// 從index位置開始進(jìn)行迭代
ListItr(int index) {
// index的有效性處理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
// 若 “index 小于 ‘雙向鏈表長度的一半'”，則從第一個(gè)元素開始往后查找；
// 否則，從最后一個(gè)元素往前查找。
if (index < (size >> )) {
next = header.next;
for (nextIndex=; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
// 是否存在下一個(gè)元素
public boolean hasNext() {
// 通過元素索引是否等于“雙向鏈表大小”來判斷是否達(dá)到最后。
return nextIndex != size;
}
// 獲取下一個(gè)元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
// next指向鏈表的下一個(gè)元素
next = next.next;
nextIndex++;
return lastReturned.element;
}
// 是否存在上一個(gè)元素
public boolean hasPrevious() {
// 通過元素索引是否等于，來判斷是否達(dá)到開頭。
return nextIndex != ;
}
// 獲取上一個(gè)元素
public E previous() {
if (nextIndex == )
throw new NoSuchElementException();
// next指向鏈表的上一個(gè)元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
// 獲取下一個(gè)元素的索引
public int nextIndex() {
return nextIndex;
}
// 獲取上一個(gè)元素的索引
public int previousIndex() {
return nextIndex-;
}
// 刪除當(dāng)前元素。
// 刪除雙向鏈表中的當(dāng)前節(jié)點(diǎn)
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}
// 設(shè)置當(dāng)前節(jié)點(diǎn)為e
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
// 將e添加到當(dāng)前節(jié)點(diǎn)的前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判斷 “modCount和expectedModCount是否相等”，依次來實(shí)現(xiàn)fail-fast機(jī)制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 雙向鏈表的節(jié)點(diǎn)所對應(yīng)的數(shù)據(jù)結(jié)構(gòu)。
// 包含部分：上一節(jié)點(diǎn)，下一節(jié)點(diǎn)，當(dāng)前節(jié)點(diǎn)值。
private static class Entry<E> {
// 當(dāng)前節(jié)點(diǎn)所包含的值
E element;
// 下一個(gè)節(jié)點(diǎn)
Entry<E> next;
// 上一個(gè)節(jié)點(diǎn)
Entry<E> previous;
/**
* 鏈表節(jié)點(diǎn)的構(gòu)造函數(shù)。
* 參數(shù)說明：
* element —— 節(jié)點(diǎn)所包含的數(shù)據(jù)
* next —— 下一個(gè)節(jié)點(diǎn)
* previous —— 上一個(gè)節(jié)點(diǎn)
*/
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
// 將節(jié)點(diǎn)(節(jié)點(diǎn)數(shù)據(jù)是e)添加到entry節(jié)點(diǎn)之前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建節(jié)點(diǎn)newEntry，將newEntry插入到節(jié)點(diǎn)e之前；并且設(shè)置newEntry的數(shù)據(jù)是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
// 修改LinkedList大小
size++;
// 修改LinkedList的修改統(tǒng)計(jì)數(shù)：用來實(shí)現(xiàn)fail-fast機(jī)制。
modCount++;
return newEntry;
}
// 將節(jié)點(diǎn)從鏈表中刪除
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
// 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
// 反向迭代器實(shí)現(xiàn)類。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
// 反向迭代器是否下一個(gè)元素。
// 實(shí)際上是判斷雙向鏈表的當(dāng)前節(jié)點(diǎn)是否達(dá)到開頭
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器獲取下一個(gè)元素。
// 實(shí)際上是獲取雙向鏈表的前一個(gè)節(jié)點(diǎn)
public E next() {
return itr.previous();
}
// 刪除當(dāng)前節(jié)點(diǎn)
public void remove() {
itr.remove();
}
}
// 返回LinkedList的Object[]數(shù)組
public Object[] toArray() {
// 新建Object[]數(shù)組
Object[] result = new Object[size];
int i = ;
// 將鏈表中所有節(jié)點(diǎn)的數(shù)據(jù)都添加到Object[]數(shù)組中
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
// 返回LinkedList的模板數(shù)組。所謂模板數(shù)組，即可以將T設(shè)為任意的數(shù)據(jù)類型
public <T> T[] toArray(T[] a) {
// 若數(shù)組a的大小 < LinkedList的元素個(gè)數(shù)(意味著數(shù)組a不能容納LinkedList中全部元素)
// 則新建一個(gè)T[]數(shù)組，T[]的大小為LinkedList大小，并將該T[]賦值給a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
// 將鏈表中所有節(jié)點(diǎn)的數(shù)據(jù)都添加到數(shù)組a中
int i = ;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
// 克隆函數(shù)。返回LinkedList的克隆對象。
public Object clone() {
LinkedList<E> clone = null;
// 克隆一個(gè)LinkedList克隆對象
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// 新建LinkedList表頭節(jié)點(diǎn)
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 將鏈表中所有節(jié)點(diǎn)的數(shù)據(jù)都添加到克隆對象中
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// java.io.Serializable的寫入函數(shù)
// 將LinkedList的“容量，所有的元素值”都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// 寫入“容量”
s.writeInt(size);
// 將鏈表中所有節(jié)點(diǎn)的數(shù)據(jù)都寫入到輸出流中
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
// java.io.Serializable的讀取函數(shù)：根據(jù)寫入方式反向讀出
// 先將LinkedList的“容量”讀出，然后將“所有的元素值”讀出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// 從輸入流中讀取“容量”
int size = s.readInt();
// 新建鏈表表頭節(jié)點(diǎn)
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// 從輸入流中將“所有的元素值”并逐個(gè)添加到鏈表中
for (int i=; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
總結(jié)：
(01) LinkedList 實(shí)際上是通過雙向鏈表去實(shí)現(xiàn)的。
它包含一個(gè)非常重要的內(nèi)部類：Entry。Entry是雙向鏈表節(jié)點(diǎn)所對應(yīng)的數(shù)據(jù)結(jié)構(gòu)，它包括的屬性有：當(dāng)前節(jié)點(diǎn)所包含的值，上一個(gè)節(jié)點(diǎn)，下一個(gè)節(jié)點(diǎn)。
(02) 從LinkedList的實(shí)現(xiàn)方式中可以發(fā)現(xiàn)，它不存在LinkedList容量不足的問題。
(03) LinkedList的克隆函數(shù)，即是將全部元素克隆到一個(gè)新的LinkedList對象中。
(04) LinkedList實(shí)現(xiàn)java.io.Serializable。當(dāng)寫入到輸出流時(shí)，先寫入“容量”，再依次寫入“每一個(gè)節(jié)點(diǎn)保護(hù)的值”；當(dāng)讀出輸入流時(shí)，先讀取“容量”，再依次讀取“每一個(gè)元素”。
(05) 由于LinkedList實(shí)現(xiàn)了Deque，而Deque接口定義了在雙端隊(duì)列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操作失敗時(shí)拋出異常，另一種形式返回一個(gè)特殊值（null 或 false，具體取決于操作）。
總結(jié)起來如下表格：
第一個(gè)元素（頭部） 最后一個(gè)元素（尾部）
拋出異常 特殊值 拋出異常 特殊值
插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)
移除 removeFirst() pollFirst() removeLast() pollLast()
檢查 getFirst() peekFirst() getLast() peekLast()
(06) LinkedList可以作為FIFO(先進(jìn)先出)的隊(duì)列，作為FIFO的隊(duì)列時(shí)，下表的方法等價(jià)：
隊(duì)列方法 等效方法
add(e) addLast(e) offer(e) offerLast(e) remove() removeFirst() poll() pollFirst() element() getFirst() peek() peekFirst()
(07) LinkedList可以作為LIFO(后進(jìn)先出)的棧，作為LIFO的棧時(shí)，下表的方法等價(jià)：
棧方法 等效方法
push(e) addFirst(e)
pop() removeFirst()
peek() peekFirst()
第4部分 LinkedList遍歷方式
LinkedList遍歷方式
LinkedList支持多種遍歷方式。建議不要采用隨機(jī)訪問的方式去遍歷LinkedList，而采用逐個(gè)遍歷的方式。
(01) 第一種，通過迭代器遍歷。即通過Iterator去遍歷。
for(Iterator iter = list.iterator(); iter.hasNext();) iter.next();
(02) 通過快速隨機(jī)訪問遍歷LinkedList
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
(03) 通過另外一種for循環(huán)來遍歷LinkedList
for (Integer integ:list) ;
(04) 通過pollFirst()來遍歷LinkedList
while(list.pollFirst() != null) ;
(05) 通過pollLast()來遍歷LinkedList
while(list.pollLast() != null) ;
(06) 通過removeFirst()來遍歷LinkedList
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
(07) 通過removeLast()來遍歷LinkedList
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
測試這些遍歷方式效率的代碼如下：
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
/*
* @desc 測試LinkedList的幾種遍歷方式和效率
*
*
*/
public class LinkedListThruTest {
public static void main(String[] args) {
// 通過Iterator遍歷LinkedList
iteratorLinkedListThruIterator(getLinkedList()) ;
// 通過快速隨機(jī)訪問遍歷LinkedList
iteratorLinkedListThruForeach(getLinkedList()) ;
// 通過for循環(huán)的變種來訪問遍歷LinkedList
iteratorThroughFor(getLinkedList()) ;
// 通過PollFirst()遍歷LinkedList
iteratorThroughPollFirst(getLinkedList()) ;
// 通過PollLast()遍歷LinkedList
iteratorThroughPollLast(getLinkedList()) ;
// 通過removeFirst()遍歷LinkedList
iteratorThroughRemoveFirst(getLinkedList()) ;
// 通過removeLast()遍歷LinkedList
iteratorThroughRemoveLast(getLinkedList()) ;
}
private static LinkedList getLinkedList() {
LinkedList llist = new LinkedList();
for (int i=; i<; i++)
llist.addLast(i);
return llist;
}
/**
* 通過快迭代器遍歷LinkedList
*/
private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
for(Iterator iter = list.iterator(); iter.hasNext();)
iter.next();
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorLinkedListThruIterator：" + interval+" ms");
}
/**
* 通過快速隨機(jī)訪問遍歷LinkedList
*/
private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
int size = list.size();
for (int i=; i<size; i++) {
list.get(i);
}
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorLinkedListThruForeach：" + interval+" ms");
}
/**
* 通過另外一種for循環(huán)來遍歷LinkedList
*/
private static void iteratorThroughFor(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
for (Integer integ:list)
;
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughFor：" + interval+" ms");
}
/**
* 通過pollFirst()來遍歷LinkedList
*/
private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
while(list.pollFirst() != null)
;
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughPollFirst：" + interval+" ms");
}
/**
* 通過pollLast()來遍歷LinkedList
*/
private static void iteratorThroughPollLast(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
while(list.pollLast() != null)
;
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughPollLast：" + interval+" ms");
}
/**
* 通過removeFirst()來遍歷LinkedList
*/
private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughRemoveFirst：" + interval+" ms");
}
/**
* 通過removeLast()來遍歷LinkedList
*/
private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時(shí)間
long start = System.currentTimeMillis();
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
// 記錄結(jié)束時(shí)間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughRemoveLast：" + interval+" ms");
}
}
執(zhí)行結(jié)果：
iteratorLinkedListThruIterator：8 ms iteratorLinkedListThruForeach：3724 ms iteratorThroughFor2：5 ms iteratorThroughPollFirst：8 ms iteratorThroughPollLast：6 ms iteratorThroughRemoveFirst：2 ms iteratorThroughRemoveLast：2 ms
由此可見，遍歷LinkedList時(shí)，使用removeFist()或removeLast()效率最高。但用它們遍歷時(shí)，會(huì)刪除原始數(shù)據(jù)；若單純只讀取，而不刪除，應(yīng)該使用第3種遍歷方式。
無論如何，千萬不要通過隨機(jī)訪問去遍歷LinkedList！
第5部分 LinkedList示例
下面通過一個(gè)示例來學(xué)習(xí)如何使用LinkedList的常用API
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
/*
* @desc LinkedList測試程序。
*
*
*
*/
public class LinkedListTest {
public static void main(String[] args) {
// 測試LinkedList的API
testLinkedListAPIs() ;
// 將LinkedList當(dāng)作 LIFO(后進(jìn)先出)的堆棧
useLinkedListAsLIFO();
// 將LinkedList當(dāng)作 FIFO(先進(jìn)先出)的隊(duì)列
useLinkedListAsFIFO();
}
/*
* 測試LinkedList中部分API
*/
private static void testLinkedListAPIs() {
String val = null;
//LinkedList llist;
//llist.offer("10");
// 新建一個(gè)LinkedList
LinkedList llist = new LinkedList();
//---- 添加操作 ----
// 依次添加1,2,3
llist.add("1");
llist.add("2");
llist.add("3");
// 將“4”添加到第一個(gè)位置
llist.add(1, "4");
System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
// (01) 將“10”添加到第一個(gè)位置。 失敗的話，拋出異常！
llist.addFirst("10");
System.out.println("llist:"+llist);
// (02) 將第一個(gè)元素刪除。 失敗的話，拋出異常！
System.out.println("llist.removeFirst():"+llist.removeFirst());
System.out.println("llist:"+llist);
// (03) 獲取第一個(gè)元素。 失敗的話，拋出異常！
System.out.println("llist.getFirst():"+llist.getFirst());
System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
// (01) 將“10”添加到第一個(gè)位置。 返回true。
llist.offerFirst("10");
System.out.println("llist:"+llist);
// (02) 將第一個(gè)元素刪除。 失敗的話，返回null。
System.out.println("llist.pollFirst():"+llist.pollFirst());
System.out.println("llist:"+llist);
// (03) 獲取第一個(gè)元素。 失敗的話，返回null。
System.out.println("llist.peekFirst():"+llist.peekFirst());
System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
// (01) 將“20”添加到最后一個(gè)位置。 失敗的話，拋出異常！
llist.addLast("20");
System.out.println("llist:"+llist);
// (02) 將最后一個(gè)元素刪除。 失敗的話，拋出異常！
System.out.println("llist.removeLast():"+llist.removeLast());
System.out.println("llist:"+llist);
// (03) 獲取最后一個(gè)元素。 失敗的話，拋出異常！
System.out.println("llist.getLast():"+llist.getLast());
System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
// (01) 將“20”添加到第一個(gè)位置。 返回true。
llist.offerLast("20");
System.out.println("llist:"+llist);
// (02) 將第一個(gè)元素刪除。 失敗的話，返回null。
System.out.println("llist.pollLast():"+llist.pollLast());
System.out.println("llist:"+llist);
// (03) 獲取第一個(gè)元素。 失敗的話，返回null。
System.out.println("llist.peekLast():"+llist.peekLast());
// 將第3個(gè)元素設(shè)置300。不建議在LinkedList中使用此操作，因?yàn)樾实停?
llist.set(2, "300");
// 獲取第3個(gè)元素。不建議在LinkedList中使用此操作，因?yàn)樾实停?
System.out.println("\nget(3):"+llist.get(2));
// ---- toArray(T[] a) ----
// 將LinkedList轉(zhuǎn)行為數(shù)組
String[] arr = (String[])llist.toArray(new String[]);
for (String str:arr)
System.out.println("str:"+str);
// 輸出大小
System.out.println("size:"+llist.size());
// 清空LinkedList
llist.clear();
// 判斷LinkedList是否為空
System.out.println("isEmpty():"+llist.isEmpty()+"\n");
}
/**
* 將LinkedList當(dāng)作 LIFO(后進(jìn)先出)的堆棧
*/
private static void useLinkedListAsLIFO() {
System.out.println("\nuseLinkedListAsLIFO");
// 新建一個(gè)LinkedList
LinkedList stack = new LinkedList();
// 將1,2,3,4添加到堆棧中
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
// 打印“棧”
System.out.println("stack:"+stack);
// 刪除“棧頂元素”
System.out.println("stack.pop():"+stack.pop());
// 取出“棧頂元素”
System.out.println("stack.peek():"+stack.peek());
// 打印“?！?
System.out.println("stack:"+stack);
}
/**
* 將LinkedList當(dāng)作 FIFO(先進(jìn)先出)的隊(duì)列
*/
private static void useLinkedListAsFIFO() {
System.out.println("\nuseLinkedListAsFIFO");
// 新建一個(gè)LinkedList
LinkedList queue = new LinkedList();
// 將10,20,30,40添加到隊(duì)列。每次都是插入到末尾
queue.add("10");
queue.add("20");
queue.add("30");
queue.add("40");
// 打印“隊(duì)列”
System.out.println("queue:"+queue);
// 刪除(隊(duì)列的第一個(gè)元素)
System.out.println("queue.remove():"+queue.remove());
// 讀取(隊(duì)列的第一個(gè)元素)
System.out.println("queue.element():"+queue.element());
// 打印“隊(duì)列”
System.out.println("queue:"+queue);
}
}
運(yùn)行結(jié)果：
Test "addFirst(), removeFirst(), getFirst()" llist:[10, 1, 4, 2, 3] llist.removeFirst():10 llist:[1, 4, 2, 3] llist.getFirst():1 Test "offerFirst(), pollFirst(), peekFirst()" llist:[10, 1, 4, 2, 3] llist.pollFirst():10 llist:[1, 4, 2, 3] llist.peekFirst():1 Test "addLast(), removeLast(), getLast()" llist:[1, 4, 2, 3, 20] llist.removeLast():20 llist:[1, 4, 2, 3] llist.getLast():3 Test "offerLast(), pollLast(), peekLast()" llist:[1, 4, 2, 3, 20] llist.pollLast():20 llist:[1, 4, 2, 3] llist.peekLast():3 get(3):300 str:1 str:4 str:300 str:3 size:4 isEmpty():true useLinkedListAsLIFO stack:[4, 3, 2, 1] stack.pop():4 stack.peek():3 stack:[3, 2, 1] useLinkedListAsFIFO queue:[10, 20, 30, 40] queue.remove():10 queue.element():20 queue:[20, 30, 40]
以上所述是小編給大家介紹的Java中LinkedList詳解和使用示例，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！
相關(guān)文章
這篇文章主要為大家介紹了springboot亂碼問題排查思路解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-06-06
java返回前端樹形結(jié)構(gòu)數(shù)據(jù)的2種實(shí)現(xiàn)方式
近期項(xiàng)目有個(gè)需求,需要將組織機(jī)構(gòu)數(shù)據(jù)拼成樹型結(jié)構(gòu)返回至前端,下面這篇文章主要給大家介紹了關(guān)于java返回前端樹形結(jié)構(gòu)數(shù)據(jù)的2種實(shí)現(xiàn)方式,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下2024-05-05
springboot默認(rèn)讀取的配置文件名字是：“application.properties”和“application.yml”，默認(rèn)讀取四個(gè)位置的文件：根目錄下、根目錄的config目錄下、classpath目錄下、classpath目錄里的config目錄下2022-10-10
Java 如何讀取Excel格式xls、xlsx數(shù)據(jù)工具類
這篇文章主要介紹了Java 如何讀取Excel格式xls、xlsx數(shù)據(jù)工具類的操作，具有很好的參考價(jià)值，希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-09-09
Scala 操作Redis使用連接池工具類RedisUtil
這篇文章主要介紹了Scala 操作Redis使用連接池工具類RedisUtil，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-06-06
Maven設(shè)置JDK版本的兩種方法實(shí)現(xiàn)
本文主要介紹了Maven設(shè)置JDK版本的兩種方法實(shí)現(xiàn),是通過Apache Maven Compiler Plugin插件實(shí)現(xiàn)的,具有一定的參考價(jià)值,感興趣的可以了解一下2024-07-07
SpringBoot 如何使用 JWT 保護(hù) Rest Api&nbs
使用spring-boot開發(fā)RESTful API非常的方便,在生產(chǎn)環(huán)境中,對發(fā)布的 API 增加授權(quán)保護(hù)是非常必要的,現(xiàn)在我們來看如何利用JWT技術(shù)為API 增加授權(quán)保護(hù),保證只有獲得授權(quán)的用戶才能夠訪問 API,感興趣的朋友跟隨小編一起看看吧2024-02-02
Springboot源碼 AbstractAdvisorAutoProxyCreator解析
這篇文章主要介紹了Springboot源碼 AbstractAdvisorAutoProxyCreator解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2019-08-08
SpringBoot啟動(dòng)后啟動(dòng)內(nèi)嵌瀏覽器的方法
這篇文章主要介紹了SpringBoot啟動(dòng)后啟動(dòng)內(nèi)嵌瀏覽器的方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-12-12
java客戶端Jedis操作Redis Sentinel 連接池的實(shí)現(xiàn)方法
下面小編就為大家?guī)硪黄猨ava客戶端Jedis操作Redis Sentinel 連接池的實(shí)現(xiàn)方法。小編覺得挺不錯(cuò)的，現(xiàn)在就分享給大家，也給大家做個(gè)參考。一起跟隨小編過來看看吧2017-03-03