Linklist详解_IT分享知识网

大家好，欢迎来到IT知识分享网。

一.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()遍历

- Foreach循环遍历

for(Integer i : linkedList);

 -通过pollFirst()或pollLast()遍历

 -通过removeFirst()或removeLast()遍历

 - 效率测试  测试以上几种遍历方式的效率，部分代码如下：

/ 遍历操作 /
System.out.println(“—————————————–”);
linkedList.clear();
for(int i = 0; i < ; 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”);

输出：

由测试结果可以看出，遍历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源码解析

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); } }

 第一个元素（头部） 最后一个元素（尾部） 抛出异常 特殊值 抛出异常 特殊值 插入 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 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); 83 // (03) 获取第一个元素。 失败的话，返回null。 84 System.out.println("llist.peekLast():"+llist.peekLast()); 85 86 87 88 // 将第3个元素设置300。不建议在LinkedList中使用此操作，因为效率低！ 89 llist.set(2, "300"); 90 // 获取第3个元素。不建议在LinkedList中使用此操作，因为效率低！ 91 System.out.println("\nget(3):"+llist.get(2)); 92 93 94 // ---- toArray(T[] a) ---- 95 // 将LinkedList转行为数组 96 String[] arr = (String[])llist.toArray(new String[0]); 97 for (String str:arr) 98 System.out.println("str:"+str); 99 100 // 输出大小 101 System.out.println("size:"+llist.size()); 102 // 清空LinkedList 103 llist.clear(); 104 // 判断LinkedList是否为空 105 System.out.println("isEmpty():"+llist.isEmpty()+"\n"); 106 107 } 108 109 / 110 * 将LinkedList当作 LIFO(后进先出)的堆栈 111 */ 112 private static void useLinkedListAsLIFO() { 113 System.out.println("\nuseLinkedListAsLIFO"); 114 // 新建一个LinkedList 115 LinkedList stack = new LinkedList(); 116 117 // 将1,2,3,4添加到堆栈中 118 stack.push("1"); 119 stack.push("2"); 120 stack.push("3"); 121 stack.push("4"); 122 // 打印“栈” 123 System.out.println("stack:"+stack); 124 125 // 删除“栈顶元素” 126 System.out.println("stack.pop():"+stack.pop()); 127 128 // 取出“栈顶元素” 129 System.out.println("stack.peek():"+stack.peek()); 130 131 // 打印“栈” 132 System.out.println("stack:"+stack); 133 } 134 135 / 136 * 将LinkedList当作 FIFO(先进先出)的队列 137 */ 138 private static void useLinkedListAsFIFO() { 139 System.out.println("\nuseLinkedListAsFIFO"); 140 // 新建一个LinkedList 141 LinkedList queue = new LinkedList(); 142 143 // 将10,20,30,40添加到队列。每次都是插入到末尾 144 queue.add("10"); 145 queue.add("20"); 146 queue.add("30"); 147 queue.add("40"); 148 // 打印“队列” 149 System.out.println("queue:"+queue); 150 151 // 删除(队列的第一个元素) 152 System.out.println("queue.remove():"+queue.remove()); 153 154 // 读取(队列的第一个元素) 155 System.out.println("queue.element():"+queue.element()); 156 157 // 打印“队列” 158 System.out.println("queue:"+queue); 159 } 160 }

运行结果：

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]

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/110511.html

Linklist详解