Java重要類之LinkList類詳解
一.LinkList概述
- LinkedList是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。
- LinkedList 實現 List 介面，能進行佇列操作。
- LinkedList 實現Deque介面，即能將LinkedList當作雙端佇列使用。
- LinkedList 實現了Cloneable介面，即覆蓋了函式clone()，能克隆。
-LinkedList 實現java.io.Serializable介面，這意味著LinkedList**支援序列化**，能通過序列化去傳輸。
LinkedList 是非同步的。 - ArrayList底層是由陣列支援，而LinkedList是由雙向連結串列實現的，其中的每個物件包含資料的同時還包含指向連結串列中前一個與後一個元素的引用。
二.LinkList的繼承關係
public class LinkedList extends AbstractSequentialList
implements List, Deque, Cloneable, Serializable
三.LinkedList與Collection關係
LinkedList的本質是雙向連結串列。
LinkedList繼承於AbstractSequentialList，並且實現了Dequeue介面。
LinkedList包含兩個重要的成員：header 和 size。
header是雙向連結串列的表頭，它是雙向連結串列節點所對應的類Entry的例項。Entry中包含成員變數： previous, next, element。其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。
size是雙向連結串列中節點的個數。
四.LinkList遍歷方式
- 迭代器遍歷
“`
Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
iterator.next();
}
- for迴圈get()遍歷
for(int i = 0; i < linkedList.size(); i++){
linkedList.get(i);
}
- Foreach迴圈遍歷
for(Integer i : linkedList);
-通過pollFirst()或pollLast()遍歷
while(linkedList.size() != 0){
linkedList.pollFirst();
}
-通過removeFirst()或removeLast()遍歷
while(linkedList.size() != 0){
linkedList.removeFirst();
}
- 效率測試
測試以上幾種遍歷方式的效率，部分程式碼如下：
/**************** 遍歷操作 **************/
System.out.println(“—————————————–”);
linkedList.clear();
for(int i = 0; i < 100000; i++){
linkedList.add(i);
}
// 迭代器遍歷
long start = System.currentTimeMillis();
Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
iterator.next();
}
long end = System.currentTimeMillis();
System.out.println(“Iterator：” + (end - start) +” ms”);
// 順序遍歷(隨機遍歷)
start = System.currentTimeMillis();
for(int i = 0; i < linkedList.size(); i++){
linkedList.get(i);
}
end = System.currentTimeMillis();
System.out.println(“for：” + (end - start) +” ms”);
// 另一種for迴圈遍歷
start = System.currentTimeMillis();
for(Integer i : linkedList);
end = System.currentTimeMillis();
System.out.println(“for2：” + (end - start) +” ms”);
// 通過pollFirst()或pollLast()來遍歷LinkedList
LinkedList temp1 = new LinkedList<>();
temp1.addAll(linkedList);
start = System.currentTimeMillis();
while(temp1.size() != 0){
temp1.pollFirst();
}
end = System.currentTimeMillis();
System.out.println(“pollFirst()或pollLast()：” + (end - start) +” ms”);
// 通過removeFirst()或removeLast()來遍歷LinkedList
LinkedList temp2 = new LinkedList<>();
temp2.addAll(linkedList);
start = System.currentTimeMillis();
while(temp2.size() != 0){
temp2.removeFirst();
}
end = System.currentTimeMillis();
System.out.println(“removeFirst()或removeLast()：” + (end - start) +” ms”);
輸出：
Iterator：17 ms
for：8419 ms
for2：12 ms
pollFirst()或pollLast()：12 ms
removeFirst()或removeLast()：10 ms
由測試結果可以看出，遍歷LinkedList時，使用removeFirst()或removeLast()效率最高，而for迴圈get()效率最低，應避免使用這種方式進行。應當注意的是，使用pollFirst()或pollLast()或removeFirst()或removeLast()遍歷時，會刪除原始資料，若只單純的讀取，應當選用第一種或第三種方式。
五.LinkList之API
// Collection中定義的API
boolean add(E object)//新增一個數組物件
boolean addAll(Collection<? extends E> collection)//新增一個包含Collection的物件
void clear()//清空
boolean contains(Object object)//包含
boolean containsAll(Collection<?> collection)
boolean equals(Object object)//判等
int hashCode()
boolean isEmpty()//判空
Iterator<E> iterator()
boolean remove(Object object)//刪除
boolean removeAll(Collection<?> collection)
boolean retainAll(Collection<?> collection)
int size()
<T> T[] toArray(T[] array)
Object[] toArray()
// AbstractCollection中定義的API
void add(int location, E object)
boolean addAll(int location, Collection<? extends E> collection)
E get(int location)//獲取某個元素值
int indexOf(Object object)
int lastIndexOf(Object object)
ListIterator<E> listIterator(int location)
ListIterator<E> listIterator()
E remove(int location)
E set(int location, E object)
List<E> subList(int start, int end)
// ArrayList新增的API
Object clone()//
void ensureCapacity(int minimumCapacity)//保證容量不小於元素個數
void trimToSize()
void removeRange(int fromIndex, int toIndex)
六.LinkList原始碼解析
為了更瞭解LinkedList的原理，下面對LinkedList原始碼程式碼作出分析。
在閱讀原始碼之前，我們先對LinkedList的整體實現進行大致說明：
LinkedList實際上是通過雙向連結串列去實現的。既然是雙向連結串列，那麼它的順序訪問會非常高效，而隨機訪問效率比較低。
既然LinkedList是通過雙向連結串列的，但是它也實現了List介面{也就是說，它實現了get(int location)、remove(int location)等“根據索引值來獲取、刪除節點的函式”}。LinkedList是如何實現List的這些介面的，如何將“雙向連結串列和索引值聯絡起來的”？
實際原理非常簡單，它就是通過一個計數索引值來實現的。例如，當我們呼叫get(int location)時，首先會比較“location”和“雙向連結串列長度的1/2”；若前者大，則從連結串列頭開始往後查詢，直到location位置；否則，從連結串列末尾開始先前查詢，直到location位置。
這就是“雙線連結串列和索引值聯絡起來”的方法。
好了，接下來開始閱讀原始碼(只要理解雙向連結串列，那麼LinkedList的原始碼很容易理解的)。
package java.util;
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 連結串列的表頭，表頭不包含任何資料。Entry是個連結串列類資料結構。
private transient Entry<E> header = new Entry<E>(null, null, null);
// LinkedList中元素個數
private transient int size = 0;
// 預設建構函式：建立一個空的連結串列
public LinkedList() {
header.next = header.previous = header;
}
// 包含“集合”的建構函式:建立一個包含“集合”的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 獲取LinkedList的第一個元素
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
// 連結串列的表頭header中不包含資料。
// 這裡返回header所指下一個節點所包含的資料。
return header.next.element;
}
// 獲取LinkedList的最後一個元素
public E getLast() {
if (size==0)
throw new NoSuchElementException();
// 由於LinkedList是雙向連結串列；而表頭header不包含資料。
// 因而，這裡返回表頭header的前一個節點所包含的資料。
return header.previous.element;
}
// 刪除LinkedList的第一個元素
public E removeFirst() {
return remove(header.next);
}
// 刪除LinkedList的最後一個元素
public E removeLast() {
return remove(header.previous);
}
// 將元素新增到LinkedList的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
// 將元素新增到LinkedList的結束位置
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) {
// 將節點(節點資料是e)新增到表頭(header)之前。
// 即，將節點新增到雙向連結串列的末端。
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中。
// 實際上，是從雙向連結串列的末尾開始，將“集合(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++;
// 設定“當前要插入節點的後一個節點”
Entry<E> successor = (index==size ? header : entry(index));
// 設定“當前要插入節點的前一個節點”
Entry<E> predecessor = successor.previous;
// 將集合(c)全部插入雙向連結串列中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
// 調整LinkedList的實際大小
size += numNew;
return true;
}
// 清空雙向連結串列
public void clear() {
Entry<E> e = header.next;
// 從表頭開始，逐個向後遍歷；對遍歷到的節點執行一下操作：
// (01) 設定前一個節點為null
// (02) 設定當前節點的內容為null
// (03) 設定後一個節點為“新的當前節點”
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
// 設定大小為0
size = 0;
modCount++;
}
// 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
}
// 設定index位置對應的節點的值為element
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
// 在index前新增節點，且節點的值為element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
// 刪除index位置的節點
public E remove(int index) {
return remove(entry(index));
}
// 獲取雙向連結串列中指定位置的節點
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
// 獲取index處的節點。
// 若index < 雙向連結串列長度的1/2,則從前先後查詢;
// 否則，從後向前查詢。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
// 從前向後查詢，返回“值為物件(o)的節點對應的索引”
// 不存在就返回-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)的節點對應的索引”
// 不存在就返回-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;
}
// 返回第一個節點
// 若LinkedList的大小為0,則返回null
public E peek() {
if (size==0)
return null;
return getFirst();
}
// 返回第一個節點
// 若LinkedList的大小為0,則丟擲異常
public E element() {
return getFirst();
}
// 刪除並返回第一個節點
// 若LinkedList的大小為0,則返回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;
}
// 返回第一個節點
// 若LinkedList的大小為0,則返回null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}
// 返回最後一個節點
// 若LinkedList的大小為0,則返回null
public E peekLast() {
if (size==0)
return null;
return getLast();
}
// 刪除並返回第一個節點
// 若LinkedList的大小為0,則返回null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
// 刪除並返回最後一個節點
// 若LinkedList的大小為0,則返回null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
// 將e插入到雙向連結串列開頭
public void push(E e) {
addFirst(e);
}
// 刪除並返回第一個節點
public E pop() {
return removeFirst();
}
// 從LinkedList開始向後查詢，刪除第一個值為元素(o)的節點
// 從連結串列開始查詢，如存在節點的值為元素(o)的節點，則刪除該節點
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 從LinkedList末尾向前查詢，刪除第一個值為元素(o)的節點
// 從連結串列開始查詢，如存在節點的值為元素(o)的節點，則刪除該節點
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到末尾的全部節點”對應的ListIterator物件(List迭代器)
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
// List迭代器
private class ListItr implements ListIterator<E> {
// 上一次返回的節點
private Entry<E> lastReturned = header;
// 下一個節點
private Entry<E> next;
// 下一個節點對應的索引值
private int nextIndex;
// 期望的改變計數。用來實現fail-fast機制。
private int expectedModCount = modCount;
// 建構函式。
// 從index位置開始進行迭代
ListItr(int index) {
// index的有效性處理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
// 若 “index 小於 ‘雙向連結串列長度的一半’”，則從第一個元素開始往後查詢；
// 否則，從最後一個元素往前查詢。
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
// 是否存在下一個元素
public boolean hasNext() {
// 通過元素索引是否等於“雙向連結串列大小”來判斷是否達到最後。
return nextIndex != size;
}
// 獲取下一個元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
// next指向連結串列的下一個元素
next = next.next;
nextIndex++;
return lastReturned.element;
}
// 是否存在上一個元素
public boolean hasPrevious() {
// 通過元素索引是否等於0，來判斷是否達到開頭。
return nextIndex != 0;
}
// 獲取上一個元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
// next指向連結串列的上一個元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
// 獲取下一個元素的索引
public int nextIndex() {
return nextIndex;
}
// 獲取上一個元素的索引
public int previousIndex() {
return nextIndex-1;
}
// 刪除當前元素。
// 刪除雙向連結串列中的當前節點
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++;
}
// 設定當前節點為e
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
// 將e新增到當前節點的前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判斷 “modCount和expectedModCount是否相等”，依次來實現fail-fast機制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 雙向連結串列的節點所對應的資料結構。
// 包含3部分：上一節點，下一節點，當前節點值。
private static class Entry<E> {
// 當前節點所包含的值
E element;
// 下一個節點
Entry<E> next;
// 上一個節點
Entry<E> previous;
/**
* 連結串列節點的建構函式。
* 引數說明：
* element —— 節點所包含的資料
* next —— 下一個節點
* previous —— 上一個節點
*/
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
// 將節點(節點資料是e)新增到entry節點之前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建節點newEntry，將newEntry插入到節點e之前；並且設定newEntry的資料是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
// 修改LinkedList大小
size++;
// 修改LinkedList的修改統計數：用來實現fail-fast機制。
modCount++;
return newEntry;
}
// 將節點從連結串列中刪除
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();
}
// 反向迭代器實現類。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
// 反向迭代器是否下一個元素。
// 實際上是判斷雙向連結串列的當前節點是否達到開頭
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器獲取下一個元素。
// 實際上是獲取雙向連結串列的前一個節點
public E next() {
return itr.previous();
}
// 刪除當前節點
public void remove() {
itr.remove();
}
}
// 返回LinkedList的Object[]陣列
public Object[] toArray() {
// 新建Object[]陣列
Object[] result = new Object[size];
int i = 0;
// 將連結串列中所有節點的資料都新增到Object[]陣列中
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
// 返回LinkedList的模板陣列。所謂模板陣列，即可以將T設為任意的資料型別
public <T> T[] toArray(T[] a) {
// 若陣列a的大小 < LinkedList的元素個數(意味著陣列a不能容納LinkedList中全部元素)
// 則新建一個T[]陣列，T[]的大小為LinkedList大小，並將該T[]賦值給a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
// 將連結串列中所有節點的資料都新增到陣列a中
int i = 0;
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;
}
// 克隆函式。返回LinkedList的克隆物件。
public Object clone() {
LinkedList<E> clone = null;
// 克隆一個LinkedList克隆物件
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// 新建LinkedList表頭節點
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 將連結串列中所有節點的資料都新增到克隆物件中
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// java.io.Serializable的寫入函式
// 將LinkedList的“容量，所有的元素值”都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// 寫入“容量”
s.writeInt(size);
// 將連結串列中所有節點的資料都寫入到輸出流中
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
// java.io.Serializable的讀取函式：根據寫入方式反向讀出
// 先將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();
// 新建連結串列表頭節點
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// 從輸入流中將“所有的元素值”並逐個新增到連結串列中
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}總結：
1.LinkedList 實際上是通過雙向連結串列去實現的。
它包含一個非常重要的內部類：Entry。Entry是雙向連結串列節點所對應的資料結構，它包括的屬性有：當前節點所包含的值，上一個節點，下一個節點。
2.從LinkedList的實現方式中可以發現，它不存在LinkedList容量不足的問題。
3.LinkedList的克隆函式，即是將全部元素克隆到一個新的LinkedList物件中。
4.LinkedList實現java.io.Serializable。當寫入到輸出流時，先寫入“容量”，再依次寫入“每一個節點保護的值”；當讀出輸入流時，先讀取“容量”，再依次讀取“每一個元素”。
5.由於LinkedList實現了Deque，而Deque介面定義了在雙端佇列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操作失敗時丟擲異常，另一種形式返回一個特殊值（null 或 false，具體取決於操作）。
總結起來如下表格：
第一個元素（頭部） 最後一個元素（尾部）
丟擲異常 特殊值 丟擲異常 特殊值
插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)
移除 removeFirst() pollFirst() removeLast() pollLast()
檢查 getFirst() peekFirst() getLast() peekLast()6.LinkedList可以作為FIFO(先進先出)的佇列，作為FIFO的佇列時，下表的方法等價：
佇列方法 等效方法
add(e) addLast(e)
offer(e) offerLast(e)
remove() removeFirst()
poll() pollFirst()
element() getFirst()
peek() peekFirst()7.LinkedList可以作為LIFO(後進先出)的棧，作為LIFO的棧時，下表的方法等價：
棧方法 等效方法
push(e) addFirst(e)
pop() removeFirst()
peek() peekFirst()8.無論如何，千萬不要通過隨機訪問去遍歷LinkedList！
七.LinkedList示例
import java.util.List;
2 import java.util.Iterator;
3 import java.util.LinkedList;
4 import java.util.NoSuchElementException;
5
6 /*
7 * @desc LinkedList測試程式。
8 *
9 * @author skywang
10 * @email [email protected]
11 */
12 public class LinkedListTest {
13 public static void main(String[] args) {
14 // 測試LinkedList的API
15 testLinkedListAPIs() ;
16
17 // 將LinkedList當作 LIFO(後進先出)的堆疊
18 useLinkedListAsLIFO();
19
20 // 將LinkedList當作 FIFO(先進先出)的佇列
21 useLinkedListAsFIFO();
22 }
23
24 /*
25 * 測試LinkedList中部分API
26 */
27 private static void testLinkedListAPIs() {
28 String val = null;
29 //LinkedList llist;
30 //llist.offer("10");
31 // 新建一個LinkedList
32 LinkedList llist = new LinkedList();
33 //---- 新增操作 ----
34 // 依次新增1,2,3
35 llist.add("1");
36 llist.add("2");
37 llist.add("3");
38
39 // 將“4”新增到第一個位置
40 llist.add(1, "4");
41
42
43 System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
44 // (01) 將“10”新增到第一個位置。 失敗的話，丟擲異常！
45 llist.addFirst("10");
46 System.out.println("llist:"+llist);
47 // (02) 將第一個元素刪除。 失敗的話，丟擲異常！
48 System.out.println("llist.removeFirst():"+llist.removeFirst());
49 System.out.println("llist:"+llist);
50 // (03) 獲取第一個元素。 失敗的話，丟擲異常！
51 System.out.println("llist.getFirst():"+llist.getFirst());
52
53
54 System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
55 // (01) 將“10”新增到第一個位置。 返回true。
56 llist.offerFirst("10");
57 System.out.println("llist:"+llist);
58 // (02) 將第一個元素刪除。 失敗的話，返回null。
59 System.out.println("llist.pollFirst():"+llist.pollFirst());
60 System.out.println("llist:"+llist);
61 // (03) 獲取第一個元素。 失敗的話，返回null。
62 System.out.println("llist.peekFirst():"+llist.peekFirst());
63
64
65 System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
66 // (01) 將“20”新增到最後一個位置。 失敗的話，丟擲異常！
67 llist.addLast("20");
68 System.out.println("llist:"+llist);
69 // (02) 將最後一個元素刪除。 失敗的話，丟擲異常！
70 System.out.println("llist.removeLast():"+llist.removeLast());
71 System.out.println("llist:"+llist);
72 // (03) 獲取最後一個元素。 失敗的話，丟擲異常！
73 System.out.println("llist.getLast():"+llist.getLast());
74
75
76 System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
77 // (01) 將“20”新增到第一個位置。 返回true。
78 llist.offerLast("20");
79 System.out.println("llist:"+llist);
80 // (02) 將第一個元素刪除。 失敗的話，返回null。
81 System.out.println("llist.pollLast():"+llist.pollLast());
82 System.out.println("llist:"+llist);
相關推薦
Java重要類之LinkList類詳解
一.LinkList概述
LinkedList是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。
LinkedList 實現 List 介面，能進行佇列操作。
LinkedList 實現Deq
聚類之效能度量詳解
概念簡述
聚類是什麼呢？我們都聽說過“物以類聚”，即把“志同道合”的 資料分到一起歸為一類，不同類之間在”志向“上具有較大分歧。舉個栗子，茫茫人生中，我們普通大眾會被God根據緣分進行聚類，緣分好的話，會成為朋友，甚至成為了可以互訴衷腸，”餘生請指教“的男女盤
你不可不知的Java引用型別之ReferenceQueue原始碼詳解
定義
引用佇列是用於儲存要回收的引用物件的引用佇列。
說明
對於軟引用、弱引用和虛擬引用，如果希望在垃圾收集器回收物件以進行其他處理時得到通知，則需要使用引用佇列。
當垃圾收集器掃描要回收的物件時，將對應的引用包裝器類（引用物件）放入其註冊的引用佇列佇列中。可以從佇列中獲得相應的物件
你不可不知的Java引用型別之——SoftReference原始碼詳解
定義 SoftReference是軟引用，其引用的物件在記憶體不足的時候會被回收。只有軟引用指向的物件稱為軟可達（softly-reachable）物件。 說明 垃圾回收器會在記憶體不足，經過一次垃圾回收後，記憶體仍舊不足的時候回收掉軟可達物件。在虛擬機器丟擲OOM
你不可不知的Java引用型別之——WeakReference原始碼詳解
定義
WeakReference是弱引用，該引用不會影響垃圾回收器對物件的回收，不會影響物件的生命週期。
說明
當虛擬機器在某個時間點決定要回收一個弱可達（weakly-reachable）物件時，會自動清除該物件的所有弱引用。並且會將物件變為finalizable狀態，然後把這些剛清除的弱引用放到其註
你不可不知的Java引用型別之——PhantomReference原始碼詳解
定義
PhantomReference是虛引用，該引用不會影響不會影響物件的生命週期，也無法從虛引用中獲取物件例項。
說明
原始碼介紹部分其實也沒多大內容，主要內容都在前面介紹中說完了。PhantomReference類的原始碼和WeakReference類一樣簡單：
public class Pha
java 定時任務之——cron表示式詳解
在介紹cron表示式詳解之前如果需要了解@Scheduled註解配置的可以點這裡
Cron表示式是一個字串，字串以5或6個空格隔開，分為6或7個域，每一個域代表一個含義，Cron有如下兩種語法格式：
（1） Seconds Minutes Hours Dayo
Java網路程式設計之流的詳解
前言
大部分網路程式做的事情就是接受輸入併產生輸出。讀伺服器傳送過來的資料與讀取本地檔案的資料並沒有多大的區別，同時伺服器將資料傳送給客戶端與寫資料到本地檔案也很像。
Java的IO操作基於streams實現的。輸入流讀資料，輸出流寫資料。
該系列文
JAVA 快取陣列之----ByteArrayInputStream類詳解
Java ByteArrayInputStream類
位元組陣列輸入流在記憶體中建立一個位元組陣列緩衝區，從輸入流讀取的資料儲存在該位元組陣列緩衝區中。建立位元組陣列輸入流物件有以下幾種方式。
接收位元組陣列作為引數建立：
ByteArrayInputStream
Java學習筆記之Pattern類的用法詳解 (正則表示式)
Implements: Serializable
正則表示式的編譯表示形式。
指定為字串的正則表示式必須首先被編譯為此類的例項。然後，可將得到的模式用於建立 Matcher 物件，依照正則表示式，該物件可以與任意字元序列匹配。執行匹配所涉及的所有狀態都駐留在匹配器中，
Java之陣列查詢Arrays類的binarySearch()方法詳解
Arrays類的binarySearch()方法，可以使用二分搜尋法來搜尋指定的陣列，以獲得指定物件。該方法返回要搜尋元素的索引值。binarySearch()方法提供多種過載形式，用於滿足各種型別陣
Java--父類的引用指向子類的對象詳解！
show 小明 一個 oid void get color system eight 例：
第一步.創建一個Person類
package com.maya.ball;
public class Person {
private int age;
p
Java類加載機制詳解
package itl prot 啟動 bool ddc 發現 很多 har 一、類加載器
類加載器（ClassLoader），顧名思義，即加載類的東西。在我們使用一個類之前，JVM需要先將該類的字節碼文件（.class文件）從磁盤、網絡或其他來源加載到內存中，並對字節碼進
React Native之屬性類型檢查機制詳解 PropType 變成 prop-types
word man div color object platform UC 靜態 ESS 屬性確認的作用
使用 React Native 創建的組件是可以復用的，所以我們開發的組件可能會給項目組其他同事使用。但別人可能對這個組件不熟悉，常常會忘記使用某些屬性，或者某些屬性傳
java類和對象詳解
權限 類和對象 字節 pre 空白 我們 框架 類設計 static 對象和類詳解
什麽是對象：萬物皆對象，什麽東西都是對象，例如，貓狗人
什麽是類：類是同一事物的統稱，它描述一類對象的行為和狀態。
設計類：抽象過程
Java類文件結構詳解
nature default 層次 size 原理 etc 識別 格式 def 概述：
Class文件結構是了解虛擬機的重要基礎之一，如果想深入的了解虛擬機，Class文件結構是不能不了解的。Class文件是一組以8位字節為基礎單位的二進制流，各項數據項目嚴格按照順序緊湊
爬蟲之刃----趕集網招聘類爬取案例詳解(系列四)
前言
本篇承襲之前的系列文章，開始動真格。以趕集網招聘類資訊爬取為例，詳細解說爬蟲程式構建過程。
準備工作：
閱讀之前的系列一、系列二、系列三，有一定遞進關係
登陸趕集網，瞭解下“地形”
OK，let’s go！
構建URL庫
java多執行緒物件鎖 類鎖 同步機制詳解
分享一下我老師大神的人工智慧教程吧。零基礎，通俗易懂！風趣幽默！http://www.captainbed.net/
也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
java基礎-初級（三）【類的三大特性詳解】
目錄
3、類的三大特性詳解（封裝、繼承、多型）
3.1 封裝
3.2 繼承
3.2.1 super關鍵字的使用
3.2.2 阻止繼承：final
&n
“全棧2019”Java第五十九章：抽象類與抽象方法詳解
難度
初級
學習時間
10分鐘
適合人群
零基礎
開發語言
Java
開發環境
JDK v11
IntelliJ IDEA v2018.3
文章原文連結
“全棧2019”Java第五十九章：抽象類與抽象方法詳解
下一章
“全棧2019”Java第六十章：如何定義介面