Java重要类之LinkedList

一、ArrayList与LinkedList

基本概念：List是一个接口，Arraylist和LinkedList是它的两个实现类，只是实现的方式不一样。我在“单链表java实现”一文中已经对单链表的结构和基本方法进行了实现，这里要说的LinkedList是java封装好的双向链表数据结构，而ArrayList是用数组实现的，它不是真正的链表，在初始化的时候它先对数组设置一个初始容量，当数组空间不够的时候，它会重新构建一个容量更大的数组，然后把先前的元素拷贝进去。粗略的来讲，ArrayList和LinkedList本质上的区别就是数组和列表这两种数据结构的区别。

大致区别：忽略特殊情况，一般来讲，两者有以下区别

1.ArrayList是基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.查找元素/读取数据：对于随机访问get和set，ArrayList性能优于LinkedList，ArrayList直接根据下标即可访问，而LinkedList遍历则要一步一步的移动指针。
3.新增/删除操作：add和remove，LinkedList比较占优势，其时间耗费仅仅在移动指针上。而ArrayList添加需要将后续元素后移，删除需要将后续元素前移，移动数据比较耗时。

LinkedList和ArrayList框架图

二、LinkedList结构

LinkedList是一种双向链表结构，如图所示。

LinkedList包含两个重要的成员：header 和 size。header是双向链表的表头，它是双向链表节点所对应的类Entry的实例。size是双向链表中节点的个数。

Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。

三、LinkedList API

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

LinkedList 实现 List 接口，能进行队列操作。

LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

可以查看https://www.yiibai.com/java/util/详细说明

 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)//返回指定元素的第一个匹配项的索引在此列表中，或者如果此列表中不包含该元素返回-1

 int           lastIndexOf(Object object)//返回指定元素的最后一个匹配项的索引在此列表中，或者如果此列表中不包含该元素返回-1

 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()//返回一个包含所有在此列表的正确顺序的元素的数组。

总结：

·LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法

add(e)        addLast(e)

offer(e)      offerLast(e)

remove()      removeFirst()

poll()        pollFirst()

element()     getFirst()

peek()        peekFirst()

·LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法

push(e)      addFirst(e)

pop()        removeFirst()

peek()       peekFirst()

四、LinkedList的遍历方式

1、迭代器遍历

 Iterator<Integer> iterator = linkedList.iterator();

 while(iterator.hasNext()){

     iterator.next();

 }

2、get遍历

对linkedList进行顺序遍历速度较慢，每一次get都需要从头开始搜索

 for(int i = 0; i < linkedList.size(); i++){

     linkedList.get(i);

 }

3、for遍历

 for(Integer i:linklist){

     System.out.println(i);

 }

4、遍历的同时删除元素

 while(linklist.size() != 0){

     linklist.pollFirst();          // linklist.pollLast();

 }

 while(linklist.size() != 0){

     linklist.removeFirst();       // linklist.removeLast();

 }

综上以上几种方式，第2种效率最低，尽量不采用。如果是单纯的访问元素，避免对原链表的修改，则使用方式1或3。注意：方式4在访问链表元素的同时会删除元素。

五、LinkedList源码

具体说明参考博客https://blog.csdn.net/qq_19431333/article/details/54572876

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

     }

 }

六、实例

 import java.util.Iterator;

 import java.util.LinkedList;

 public class LinkedListDemo {

     public static void main(String[] srgs){

         LinkedList<Integer> linkedList = new LinkedList<>();

         /************************** 基本操作 ************************/

         linkedList.addFirst(0);    // 添加元素到列表开头

         linkedList.add(1);         // 在列表结尾添加元素

         linkedList.add(2,2);       // 在指定位置添加元素

         linkedList.addLast(3);     // 添加元素到列表结尾

         System.out.println("LinkedList: " + linkedList);

         System.out.println("getFirst(): " + linkedList.getFirst());       // 返回此列表的第一个元素

         System.out.println("getLast(): " + linkedList.getLast());         // 返回此列表的最后一个元素

         System.out.println("removeFirst(): " + linkedList.removeFirst()); // 移除并返回此列表的第一个元素

         System.out.println("removeLast(): " + linkedList.removeLast());   // 移除并返回此列表的最后一个元素

         System.out.println("After remove:" + linkedList);

         System.out.println("contains(1) is :" + linkedList.contains(1));  // 判断此列表包含指定元素，如果是，则返回true

         System.out.println("size is : " + linkedList.size());             // 返回此列表的元素个数

         /************************** 位置访问操作 ************************/

         System.out.println("-----------------------------------------");

         linkedList.set(1, 3);                                             // 将此列表中指定位置的元素替换为指定的元素

         System.out.println("After set(1, 3):" + linkedList);

         System.out.println("get(1): " + linkedList.get(1));               // 返回此列表中指定位置处的元素

         /************************** Search操作  ************************/

         System.out.println("-----------------------------------------");

         linkedList.add(3);

         System.out.println("indexOf(3): " + linkedList.indexOf(3));        // 返回此列表中首次出现的指定元素的索引

         System.out.println("lastIndexOf(3): " + linkedList.lastIndexOf(3));// 返回此列表中最后出现的指定元素的索引

         /************************** Queue操作   队头出，队尾进************************/

         System.out.println("-----------------------------------------");

         System.out.println("peek(): " + linkedList.peek());                // 获取但不移除此列表的头

         System.out.println("element(): " + linkedList.element());          // 获取但不移除此列表的头

         linkedList.poll();                                                 // 获取并移除此列表的头

         System.out.println("After poll():" + linkedList);

         linkedList.remove();

         System.out.println("After remove():" + linkedList);                // 获取并移除此列表的头

         linkedList.offer(4);

         System.out.println("After offer(4):" + linkedList);                // 将指定元素添加到此列表的末尾  

         /************************** Deque操作   双端队列（栈+队列）************************/

         System.out.println("-----------------------------------------");

         linkedList.offerFirst(2);                                          // 在此列表的开头插入指定的元素

         System.out.println("After offerFirst(2):" + linkedList);

         linkedList.offerLast(5);                                           // 在此列表末尾插入指定的元素

         System.out.println("After offerLast(5):" + linkedList);

         System.out.println("peekFirst(): " + linkedList.peekFirst());      // 获取但不移除此列表的第一个元素

         System.out.println("peekLast(): " + linkedList.peekLast());        // 获取但不移除此列表的第一个元素

         linkedList.pollFirst();                                            // 获取并移除此列表的第一个元素

         System.out.println("After pollFirst():" + linkedList);

         linkedList.pollLast();                                             // 获取并移除此列表的最后一个元素

         System.out.println("After pollLast():" + linkedList);

         linkedList.push(2);                                                // 将元素推入此列表所表示的堆栈（插入到列表的头）

         System.out.println("After push(2):" + linkedList);

         linkedList.pop();                                                  // 从此列表所表示的堆栈处弹出一个元素（获取并移除列表第一个元素）

         System.out.println("After pop():" + linkedList);

         linkedList.add(3);

         linkedList.removeFirstOccurrence(3);                               // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表）

         System.out.println("After removeFirstOccurrence(3):" + linkedList);

         linkedList.removeLastOccurrence(3);                                // 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表）

         System.out.println("After removeFirstOccurrence(3):" + linkedList);

         /************************** 遍历操作   ************************/

         System.out.println("-----------------------------------------");

         linkedList.clear();

         for(int i = 0; i < 100000; i++){

             linkedList.add(i);

         }

         // 迭代器遍历

         long start = System.currentTimeMillis();

         Iterator<Integer> 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<Integer> 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<Integer> 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");

     }

 }

 /**Output

 LinkedList: [0, 1, 2, 3]

 getFirst(): 0

 getLast(): 3

 removeFirst(): 0

 removeLast(): 3

 After remove:[1, 2]

 contains(1) is :true

 size is : 2

 -----------------------------------------

 After set(1, 3):[1, 3]

 get(1): 3

 -----------------------------------------

 indexOf(3): 1

 lastIndexOf(3): 2

 -----------------------------------------

 peek(): 1

 element(): 1

 After poll():[3, 3]

 After remove():[3]

 After offer(4):[3, 4]

 -----------------------------------------

 After offerFirst(2):[2, 3, 4]

 After offerLast(5):[2, 3, 4, 5]

 peekFirst(): 2

 peekLast(): 5

 After pollFirst():[3, 4, 5]

 After pollLast():[3, 4]

 After push(2):[2, 3, 4]

 After pop():[3, 4]

 After removeFirstOccurrence(3):[4, 3]

 After removeFirstOccurrence(3):[4]

 -----------------------------------------

 Iterator：17 ms

 for：8419 ms

 for2：12 ms

 pollFirst()或pollLast()：12 ms

 removeFirst()或removeLast()：10 ms

 */

参考自：https://blog.csdn.net/gongchuangsu/article/details/51527042

巴特西

Java重要类之LinkedList

最新文章

热门文章