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

写在前面的话：读书破万卷，编码如有神
--------------------------------------------------------------------
下文主要对java.util.LinkedList<E>的4个位置访问操作进行介绍，主要内容包括：

1、LinkedList常用的4个位置访问操作介绍

参考内容：

1、JDK源码(1.7)

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

1、LinkedList常用的4个位置访问操作介绍

(1)E get(int index)

功能: 返回此双端队列中index位置上的节点

示例代码:

 import java.util.LinkedList;

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

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

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

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

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

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

         //此方法将抛出异常
         System.out.println("linkedList.get(5):" + linkedList.get(5));
     }
 }

 运行结果:
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.get(2):Student [stuId=3, stuName=wangwu, stuAge=22]
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 5, Size: 3
     at java.util.LinkedList.checkElementIndex(LinkedList.java:553)
     at java.util.LinkedList.get(LinkedList.java:474)
     at LinkedListDemo.main(LinkedListDemo.java:27)

源代码如下:

     /*
        返回此双端队列中index位置上的节点
     */
     public E get(int index) {
         //检查index参数是否合法，调用内部方法checkElementIndex
         checkElementIndex(index);

         //返回双端队列中index位置上的节点
         return node(index).item;
     }

     /*
         检查index参数是否合法
     */
     private void checkElementIndex(int index) {
         //如果不合法，则抛出异常
         if (!isElementIndex(index))
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /*
         检查参数index是合法
     */
     private boolean isElementIndex(int index) {
         return index >= 0 && index < size;
     }

     /*
          返回双端队列index位置上的节点
     */
     Node<E> node(int index) {
         // assert isElementIndex(index);

         if (index < (size >> 1)) {
             //如果要求返回的节点位置index,在双端队列的前一半，则从头往尾找
             Node<E> x = first;
             for (int i = 0; i < index; i++)
                 x = x.next;
             return x;
         } else {
             //如果要求返回的节点位置index,在双端队列的后一半，则从尾往头找
             Node<E> x = last;
             for (int i = size - 1; i > index; i--)
                 x = x.prev;
             return x;
         }
     }

(2)E set(int index, E element)

功能: 将此双端队列中index位置上的节点替换为element节点，并返回被替换的节点

示例代码:

 import java.util.LinkedList;

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

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

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

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

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

         Student stu4 = new Student(4,"xiaohong",22);
         System.out.println("linkedList.set(1,stu4):" + linkedList.set(1,stu4));
         System.out.println("linkedList:" + linkedList);

         //此方法将抛出异常
         System.out.println("linkedList.set(7,stu4):" + linkedList.set(7,stu4));
     }
 }

 运行结果:
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList.set(1,stu4):Student [stuId=2, stuName=lisi, stuAge=21]
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=4, stuName=xiaohong, stuAge=22], Student [stuId=3, stuName=wangwu, stuAge=22]]
 Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 7, Size: 3
     at java.util.LinkedList.checkElementIndex(LinkedList.java:553)
     at java.util.LinkedList.set(LinkedList.java:488)
     at LinkedListDemo.main(LinkedListDemo.java:28)

源代码如下:

    /*
         将此双端队列中index位置上的节点替换为element节点，并返回被替换的节点
    */
    public E set(int index, E element) {
         //检查index参数是否合法
         checkElementIndex(index);
         //查找双端队列中index位置上的节点
         Node<E> x = node(index);
         //记录要被替换的节点
         E oldVal = x.item;
         //设置双端队列中index位置上的节点的值为element
         x.item = element;
         //返回被替换的老节点
         return oldVal;
     }

(3)void add(int index, E element)

功能: 将元素element添加到双端队列的index位置上

示例代码:

 import java.util.LinkedList;

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

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

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

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

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

         Student stu4 = new Student(4,"xiaohong",22);
         linkedList.add(1,stu4);
         System.out.println("linkedList:" + linkedList);

         //此方法将抛出异常
         linkedList.add(7,stu4);
     }
 }

 运行结果:
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=4, stuName=xiaohong, stuAge=22], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
 Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 7, Size: 4
     at java.util.LinkedList.checkPositionIndex(LinkedList.java:558)
     at java.util.LinkedList.add(LinkedList.java:505)
     at LinkedListDemo.main(LinkedListDemo.java:28)

源代码如下:

     /*
       功能: 将元素element添加到双端队列的index位置
     */
     public void add(int index, E element) {

         //检查参数index是否合法
         checkPositionIndex(index);

         if (index == size){
             //添加到双端队列的尾部
             linkLast(element);
         }
         else{
             //添加在双端队列的中间
             linkBefore(element, node(index));
         }
     }    

(4)E remove(int index)

功能: 将此双端队列的index位置上的元素删除

示例代码:

 import java.util.LinkedList;

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

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

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

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

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

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

         //此方法将会抛出异常
         linkedList.remove(8);
     }
 }

 运行结果:
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]Exception in thread "main"
 linkedList.remove(2):Student [stuId=3, stuName=wangwu, stuAge=22]
 linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
 java.lang.IndexOutOfBoundsException: Index: 8, Size: 2
     at java.util.LinkedList.checkElementIndex(LinkedList.java:553)
     at java.util.LinkedList.remove(LinkedList.java:523)
     at LinkedListDemo.main(LinkedListDemo.java:27)

源代码如下:

     /*
       将此双端队列的index位置上的元素删除
    */
     public E remove(int index) {
         //检查参数index是否合法
         checkElementIndex(index);
         //删除节点
         return unlink(node(index));
     }

     //检查参数index是合法
     private void checkElementIndex(int index) {
         //调用内部方法isElementIndex检查参数index是合法，不合法则抛出异常
         if (!isElementIndex(index))
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     //检查参数index是否合法
     private boolean isElementIndex(int index) {
         return index >= 0 && index < size;
     }

     //返回此双端队列index位置上的节点元素
     Node<E> node(int index) {
         // assert isElementIndex(index);

         if (index < (size >> 1)) {
             //如果要求返回的节点位置index,在双端队列的前一半，则从头往尾找
             Node<E> x = first;
             for (int i = 0; i < index; i++)
                 x = x.next;
             return x;
         } else {
             //如果要求返回的节点位置index,在双端队列的后一半，则从尾往头找
             Node<E> x = last;
             for (int i = size - 1; i > index; i--)
                 x = x.prev;
             return x;
         }
     }

      /*
         删除双端队列中 节点x
     */
     E unlink(Node<E> x) {
         // assert x != null;
         //记录x节点的值
         final E element = x.item;
         //记录x节点的下一个节点
         final Node<E> next = x.next;
         //记录x节点的上一个节点
         final Node<E> prev = x.prev;

         if (prev == null) {
             //如果x节点没有上一个节点，则赋值双端队列对象的first属性为next
             first = next;
         } else {
             //如果x节点有上一个节点，则赋值x节点的上一个节点的next属性为next
             prev.next = next;
             x.prev = null;
         }

         if (next == null) {
             //如果x节点没有下一个节点，则赋值双端队列对象的last属性为prev
             last = prev;
         } else {
             //如果x节点有下一个节点，则赋值x节点的下一个节点的prev属性为prev
             next.prev = prev;
             x.next = null;
         }

         //设置被删除节点的值为null,方便GC
         x.item = 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>