内功心法 -- java.util.LinkedList<E> (2)

写在前面的话：读书破万卷，编码如有神
--------------------------------------------------------------------
下文主要对java.util.LinkedList<E>的构造方法和6个队列头、尾操作进行介绍，主要内容包括：

1、LinkedList构造方法介绍

2、LinkedList常用6个队头、尾操作介绍

参考内容：

1、JDK源码(1.7)

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

1、LinkedList两个构造方法

1.1、LinkedList构造方法（提供了两种构造方法）

     //第一种: 默认构造函数
     public LinkedList() {
     }

     //第二种: 带子队列参数的构造函数
     public LinkedList(Collection<? extends E> c) {
         this();
         addAll(c);
     }

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

2、LinkedList常用6个队头、尾操作介绍

(1) void addFirst(E e)

功能: 将指定的元素e插入到此双端队列的头部

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addFirst(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addFirst(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addFirst(stu3);
         System.out.println(linkedList);
     }
 }
 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=3, stuName=wangwu, stuAge=22], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=1, stuName=zhangsan, stuAge=20]]

 从运行结果可以看出，调用addFirst(E e)方法往LinkedList对象中添加元素时，所添加的元素都在头部

源代码:

     /*
       将元素e插入到此双端队列的头部
     */
     public void addFirst(E e) {
         //调用内部方法来实现
         linkFirst(e);
     }

     /*
      私有方法，将元素e链接到此双端队列的头部
     */
     private void linkFirst(E e) {
         //引用f指向此双端队列的第一个节点（头部节点）
         final Node<E> f = first;
         //创建一个Node节点
         final Node<E> newNode = new Node<>(null, e, f);
         //设置此双端队列的first属性指向 刚新创建的Node节点
         first = newNode;
         //如果此时双端队列中没有节点存在，则设置此双端队列的last属性也指向刚新建的Node节点，否则设置原来的头节点的prev属性指向刚新建的Node节点
         if (f == null)
             last = newNode;
         else
             f.prev = newNode;
         //双端队列中节点个数加1
         size++;
         //fast-fail机制加1
         modCount++;
     }

(2) void addLast(E e)

功能: 将指定的元素e插入到此双端队列的尾部

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addLast(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addLast(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addLast(stu3);
         System.out.println(linkedList);
     }
 }

 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]

 可以看出，调用LinkedList的addLast方法是将元素添加到双端队列的尾部

源代码:

     /*
        将元素e添加到此双端队列的尾部
     */
     public void addLast(E e) {
         //调用内部linkLast方法来完成
         linkLast(e);
     }

     /*
        将元素e链接到此双端队列的尾部
     */
     void linkLast(E e) {
         //引用l指向此双端队列对象的尾节点
         final Node<E> l = last;
         //新建一个Node节点
         final Node<E> newNode = new Node<>(l, e, null);
         //设置此双端队列对象的last属性指向刚新建的Node节点
         last = newNode;
         //如果此双端队列中没有节点存在，则设置此双端队列对象的first属性也指向刚新建的Node节点，否则原来的尾节点的next属性指向刚新建的Node节点
         if (l == null)
             first = newNode;
         else
             l.next = newNode;
         //双端队列中节点个数加1
         size++;
         //fast-fail机制加1
         modCount++;
     }

(3) E getFirst()

功能: 获取，但不移除此双端队列的第一个元素

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         /*********测试LinkedList的'E getFirst()'方法的使用**********/

         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addLast(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addLast(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addLast(stu3);
         System.out.println(linkedList);

         System.out.println("linkedList.getFirst() = " + linkedList.getFirst());

         //创建一个LinkedList对象
         LinkedList<Student> linkedList1 = new LinkedList<Student>();
         //此时会抛出异常
         System.out.println("linkedList1.getFirst() = " + linkedList1.getFirst());
     }
 }

 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.getFirst() = Student [stuId=1, stuName=zhangsan, stuAge=20]
 Exception in thread "main" java.util.NoSuchElementException
     at java.util.LinkedList.getFirst(LinkedList.java:242)
     at LinkedListDemo.main(LinkedListDemo.java:31)

源代码:

     /*
        获取，但不移除此双端队列的第一个元素
     */
     public E getFirst() {
         //引用f指向此双端队列对象的头节点
         final Node<E> f = first;
         //如果此双端队列中没有节点元素，则抛出异常
         if (f == null)
             throw new NoSuchElementException();
         //返回此双端队列头节点的值
         return f.item;
     }

(4) E getLast()

功能: 获取，但不移除此双端队列的最后一个元素

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         /*********测试LinkedList的'E getLast()'方法的使用**********/

         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addLast(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addLast(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addLast(stu3);
         System.out.println(linkedList);

         System.out.println("linkedList.getLast() = " + linkedList.getLast());

         //创建一个LinkedList对象
         LinkedList<Student> linkedList1 = new LinkedList<Student>();
         //此时会抛出异常
         System.out.println("linkedList1.getLast() = " + linkedList1.getLast());
     }
 }

 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.getLast() = Student [stuId=3, stuName=wangwu, stuAge=22]
 Exception in thread "main" java.util.NoSuchElementException
     at java.util.LinkedList.getLast(LinkedList.java:255)
     at LinkedListDemo.main(LinkedListDemo.java:31)

源代码:

     /*获取，但不移除此双端队列的最后一个元素*/
     public E getLast() {
         //引用l指向此双端队列对象的尾节点
         final Node<E> l = last;
         //如果此双端队列中没有节点元素，则抛出异常
         if (l == null)
             throw new NoSuchElementException();
         //返回此双端队列尾节点的值
         return l.item;
     }

(5) E removeFirst()

功能: 获取并移除此双端队列第一个元素

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         /*********测试LinkedList的'E removeFirst()'方法的使用**********/

         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addLast(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addLast(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addLast(stu3);
         System.out.println(linkedList);

         System.out.println("linkedList.removeFirst() = " + linkedList.removeFirst());
         System.out.println(linkedList);
     }
 }

 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.removeFirst() = Student [stuId=1, stuName=zhangsan, stuAge=20]
 [Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]

源代码:

     /*
        获取并移除此双端队列第一个节点
     */
     public E removeFirst() {
         //引用f指向此双端队列对象的头节点
         final Node<E> f = first;
         //如果此双端队列中没有节点元素，则抛出异常
         if (f == null)
             throw new NoSuchElementException();
         //调用内部方法unlinkFirst()方法
         return unlinkFirst(f);
     }

     /*

     */
     private E unlinkFirst(Node<E> f) {
         // assert f == first && f != null;
         //记录此双端队列的头节点
         final E element = f.item;
         //记录此双端队列的头节点的下一个节点
         final Node<E> next = f.next;

         //将引用设置null,帮助GC回收
         f.item = null;
         f.next = null; // help GC

         //赋值此双端队列对象的first属性 = next
         first = next;
         //如果此双端对象中只有一个节点，则设置此双端队列对象的last属性为null,否则设置next引用指向的节点的prev=null
         if (next == null)
             last = null;
         else
             next.prev = null;
         //设置双端队列中元素个数减1
         size--;
         //fast-fail机制加1
         modCount++;
         //返回删除的节点
         return element;
     }

(6) E removeLast()

功能: 获取并移除此双端队列的最后一个元素

示例代码:

 import java.util.LinkedList;

 public class LinkedListDemo {
     public static void main(String[] args) {
         /*********测试LinkedList的'E removeLast()'方法的使用**********/

         //创建一个LinkedList对象
         LinkedList<Student> linkedList = new LinkedList<Student>();

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu1 = new Student(1,"zhangsan",20);
         linkedList.addLast(stu1);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu2 = new Student(2,"lisi",21);
         linkedList.addLast(stu2);
         System.out.println(linkedList);

         //创建一个Student对象，并将其添加到LinkedList对象中
         Student stu3 = new Student(3,"wangwu",22);
         linkedList.addLast(stu3);
         System.out.println(linkedList);

         System.out.println("linkedList.removeLast() = " + linkedList.removeLast());
         System.out.println(linkedList);

         //创建一个LinkedList对象
         LinkedList<Student> linkedList2 = new LinkedList<Student>();
         //此方法将会抛出异常
         linkedList2.removeLast();
     }
 }

 运行结果:
 [Student [stuId=1, stuName=zhangsan, stuAge=20]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.removeLast() = Student [stuId=3, stuName=wangwu, stuAge=22]
 [Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 Exception in thread "main" java.util.NoSuchElementException
     at java.util.LinkedList.removeLast(LinkedList.java:281)
     at LinkedListDemo.main(LinkedListDemo.java:31)

源代码:

     /*
       获取并移除此双端队列最后一个节点
     */
     public E removeLast() {
         //引用l指向此双端队列对象的尾节点
         final Node<E> l = last;
         //如果此双端队列中没有节点元素，则抛出异常
         if (l == null)
             throw new NoSuchElementException();
         //调用内部方法unlinkLast()
         return unlinkLast(l);
     }

     /*
       获取并移除此双端队列最后一个节点
     */
     private E unlinkLast(Node<E> l) {
         // assert l == last && l != null;
         //记录此双端队列的尾节点
         final E element = l.item;
         //记录此双端队列的尾节点的前一个节点
         final Node<E> prev = l.prev;
         //将引用设置null,帮助GC回收
         l.item = null;
         l.prev = null; // help GC

         //赋值此双端队列对象的last属性 = prev
         last = prev;
         //如果此双端对象中只有一个节点，则设置此双端队列对象的first属性为null,否则设置prev引用指向的节点的next=null
         if (prev == null)
             first = null;
         else
             prev.next = null;
         //设置双端队列中元素个数减1
         size--;
         //fast-fail机制加1
         modCount++;
         //返回删除的节点
         return element;
     }

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

java.util.LinkedList<E>系列文章

java.util.LinkedList<E>(1)　　java.util.LinkedList<E>(2)　　java.util.LinkedList<E>(3)

java.util.LinkedList<E>(4)　　java.util.LinkedList<E>(5)　　java.util.LinkedList<E>(6)

java.util.LinkedList<E>(7)　　java.util.LinkedList<E>(8)　　

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

相关知识

java.util.Collection<E> 　　java.util.AbstractCollection<E> 　　java.util.List<E>

java.util.AbstractList<E> 　　java.util.Iterator<E> 　　java.util.ListIterator<E>

Java中的标记接口 　　迭代器模式 　　Java中的深拷贝和浅拷贝  java.util.Arrays

java.util.Queue<E>　　java.util.Deque<E>