程序博客网 > mac系统格式化u盘

LinkedList源码探讨（基于JDK1.8）

来源：互联网 发布：mac系统格式化u盘 编辑：程序博客网 时间：2024/05/10 16:14
LinkedList类结构

通过LinkedList实现的接口可知，其支持队列操作，双向列表操作，能被克隆，支持序列化。
  1. public class LinkedList<E>
  2.     extends AbstractSequentialList<E>
  3.     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

LinkedList有三个重要的成员变量
transient int size = 0; //添加到链表中元素个数
transient Node<E> first; //头结点
transient Node<E> last; //尾结点
  1.  private static class Node<E> {
  2.         E item;
  3.         Node<E> next;
  4.         Node<E> prev;
  6.         Node(Node<E> prev, E element, Node<E> next) {
  7.             this.item = element;
  8.             this.next = next;
  9.             this.prev = prev;
  10.         }
  11.     }

LinkedList添加元素方法
  1. //头插入，在列表首部插入节点值e
  2.     public void addFirst(E e) {
  3.         linkFirst(e);
  4.     }
  6.     //头插入，即将节点值为e的节点设置为链表首节点
  7.     private void linkFirst(E e) {
  8.         final Node<E> f = first;
  9.         //构建一个prev值为null,节点值为e,next值为f的新节点newNode
  10.         final Node<E> newNode = new Node<>(null, e, f); 
  11.         //将newNode作为首节点
  12.         first = newNode;
  13.         //如果原首节点为null，即原链表为null，则链表尾节点也设置为newNode
  14.         if (f == null)
  15.             last = newNode; 
  16.         else //否则，原首节点的prev设置为newNode
  17.             f.prev = newNode;
  18.         size++;  
  19.         modCount++;
  20.     }
  22.     //尾插入，在列表尾部插入节点值e，该方法等价于add()
  23.     public void addLast(E e) {
  24.         linkLast(e);
  25.     }
  27.     //尾插入，在列表尾部插入节点值e
  28.     public boolean add(E e) {
  29.         linkLast(e);
  30.         return true;
  31.     }    
  33.     //尾插入，即将节点值为e的节点设置为链表的尾节点
  34.     void linkLast(E e) {
  35.         final Node<E> l = last;
  36.         //构建一个prev值为l,节点值为e,next值为null的新节点newNode
  37.         final Node<E> newNode = new Node<>(l, e, null);
  38.         //将newNode作为尾节点
  39.         last = newNode;
  40.         //如果原尾节点为null，即原链表为null，则链表首节点也设置为newNode
  41.         if (l == null)
  42.             first = newNode; 
  43.         else  //否则，原尾节点的next设置为newNode
  44.             l.next = newNode;
  45.         size++;
  46.         modCount++;
  47.     }
  49.     //中间插入，在非空节点succ之前插入节点值e
  50.     void linkBefore(E e, Node<E> succ) {
  51.         // assert succ != null;
  52.         final Node<E> pred = succ.prev;
  53.         //构建一个prev值为succ.prev,节点值为e,next值为succ的新节点newNode
  54.         final Node<E> newNode = new Node<>(pred, e, succ);
  55.         //设置newNode为succ的前节点
  56.         succ.prev = newNode;
  57.         //如果succ.prev为null，即如果succ为首节点，则将newNode设置为首节点
  58.         if (pred == null)  
  59.             first = newNode;
  60.         else //如果succ不是首节点
  61.             pred.next = newNode;
  62.         size++;
  63.         modCount++;
  64.     }
  66.     /**
  67.      * 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此链表的尾部
  68.      * 如果指定的集合添加到链表的尾部的过程中，集合被修改，则该插入过程的后果是不确定的。
  69.      * 一般这种情况发生在指定的集合为该链表的一部分，且其非空。
  70.      * @throws NullPointerException 指定集合为null
  71.      */
  72.     public boolean addAll(Collection<? extends E> c) {
  73.         return addAll(size, c);
  74.     }
  76.     //从指定的位置开始，将指定collection中的所有元素插入到此链表中，新元素的顺序为指定collection的迭代器所返回的元素顺序
  77.     public boolean addAll(int index, Collection<? extends E> c) {
  78.         checkPositionIndex(index); //index >= 0 && index <= size
  80.         Object[] a = c.toArray();
  81.         int numNew = a.length;
  82.         if (numNew == 0) 
  83.             return false;
  85.         Node<E> pred, succ; //succ指向当前需要插入节点的位置，pred指向其前一个节点
  86.         if (index == size) { //说明在列表尾部插入集合元素
  87.             succ = null;
  88.             pred = last;
  89.         } else {
  90.             succ = node(index); //得到索引index所对应的节点
  91.             pred = succ.prev;
  92.         }
  94.         //指定collection中的所有元素依次插入到此链表中指定位置的过程
  95.         for (Object o : a) {
  96.             @SuppressWarnings("unchecked") E e = (E) o;
  97.             //将元素值e，前继节点pred“封装”为一个新节点newNode
  98.             Node<E> newNode = new Node<>(pred, e, null);
  99.             if (pred == null)  //如果原链表为null，则新插入的节点作为链表首节点
  100.                 first = newNode; 
  101.             else
  102.                 pred.next = newNode;
  103.             pred = newNode;  //pred指针向后移动，指向下一个需插入节点位置的前一个节点
  104.         }
  106.         //集合元素插入完成后，与原链表index位置后面的子链表链接起来
  107.         if (succ == null) { //说明之前是在列表尾部插入的集合元素
  108.             last = pred;  //pred指向的是最后插入的那个节点
  109.         } else { 
  110.             pred.next = succ;
  111.             succ.prev = pred;
  112.         }
  114.         size += numNew;
  115.         modCount++;
  116.         return true;
  117.     }
  119.     //将指定的元素(E element)插入到列表的指定位置(index)
  120.     public void add(int index, E element) {
  121.         checkPositionIndex(index); //index >= 0 && index <= size
  123.         if (index == size) 
  124.             linkLast(element); //尾插入
  125.         else
  126.             linkBefore(element, node(index));  //中间插入
  127.     }

在public void add(int index, E element)中使用到Node<E> node(int index)这个方法。此方法是返回某个index对应的结点，在遍历链表之前，先通过
if (index < (size >> 1))来判断index是否在链表的前半部分，如果在前半部分，则通过first向后遍历，也就是从前往后遍历，否则从last结点往前遍历，此种获取结点的方式避免了每次都从头遍历的弊端，也就是加快了获取速度。
  1. Node<E> node(int index) {
  2.         // assert isElementIndex(index);
  4.         if (index < (size >> 1)) {
  5.             Node<E> x = first;
  6.             for (int i = 0; i < index; i++)
  7.                 x = x.next;
  8.             return x;
  9.         } else {
  10.             Node<E> x = last;
  11.             for (int i = size - 1; i > index; i--)
  12.                 x = x.prev;
  13.             return x;
  14.         }
  15.     }


LinkedList删除元素方法
  1. //移除首节点，并返回该节点的元素值
  2.     public E removeFirst() {
  3.         final Node<E> f = first;
  4.         if (f == null)
  5.             throw new NoSuchElementException();
  6.         return unlinkFirst(f);
  7.     }
  9.     //删除非空的首节点f
  10.     private E unlinkFirst(Node<E> f) {
  11.         // assert f == first && f != null;
  12.         final E element = f.item;
  13.         final Node<E> next = f.next;
  14.         f.item = null;
  15.         f.next = null; // help GC
  16.         first = next; //将原首节点的next节点设置为首节点
  17.         if (next == null)  //如果原链表只有一个节点，即原首节点，删除后，链表为null
  18.             last = null;
  19.         else  
  20.             next.prev = null;
  21.         size--;
  22.         modCount++;
  23.         return element;
  24.     }
  26.     //移除尾节点，并返回该节点的元素值
  27.     public E removeLast() {
  28.         final Node<E> l = last;
  29.         if (l == null)
  30.             throw new NoSuchElementException();
  31.         return unlinkLast(l);
  32.     }
  34.     //删除非空的尾节点l
  35.     private E unlinkLast(Node<E> l) {
  36.         // assert l == last && l != null;
  37.         final E element = l.item;
  38.         final Node<E> prev = l.prev;
  39.         l.item = null;
  40.         l.prev = null; // help GC
  41.         last = prev; //将原尾节点的prev节点设置为尾节点
  42.         if (prev == null) //如果原链表只有一个节点,则删除后，链表为null
  43.             first = null;
  44.         else
  45.             prev.next = null;
  46.         size--;
  47.         modCount++;
  48.         return element;
  49.     }
  51.     //移除此列表中指定位置上的元素
  52.     public E remove(int index) {
  53.         checkElementIndex(index);  //index >= 0 && index < size
  54.         return unlink(node(index));
  55.     }
  57.     //删除非空节点x
  58.     E unlink(Node<E> x) {
  59.         // assert x != null;
  60.         final E element = x.item;
  61.         final Node<E> next = x.next;
  62.         final Node<E> prev = x.prev;
  64.         if (prev == null) {  //如果被删除节点为头节点
  65.             first = next;
  66.         } else {
  67.             prev.next = next;
  68.             x.prev = null; 
  69.         }
  71.         if (next == null) {  //如果被删除节点为尾节点
  72.             last = prev;
  73.         } else {
  74.             next.prev = prev;
  75.             x.next = null; 
  76.         }
  78.         x.item = null; // help GC
  79.         size--;
  80.         modCount++;
  81.         return element;
  82.     }
  84.     //移除列表中首次出现的指定元素(如果存在)，LinkedList中允许存放重复的元素
  85.     public boolean remove(Object o) {
  86.         //由于LinkedList中允许存放null，因此下面通过两种情况来分别处理
  87.         if (o == null) {
  88.             for (Node<E> x = first; x != null; x = x.next) { //顺序访问
  89.                 if (x.item == null) {
  90.                     unlink(x);
  91.                     return true;
  92.                 }
  93.             }
  94.         } else {
  95.             for (Node<E> x = first; x != null; x = x.next) {
  96.                 if (o.equals(x.item)) {
  97.                     unlink(x);
  98.                     return true;
  99.                 }
  100.             }
  101.         }
  102.         return false;
  103.     }
  105.     //清除列表中所有节点
  106.     public void clear() {
  107.         // Clearing all of the links between nodes is "unnecessary", but:
  108.         // - helps a generational GC if the discarded nodes inhabit
  109.         //   more than one generation
  110.         // - is sure to free memory even if there is a reachable Iterator
  111.         for (Node<E> x = first; x != null; ) {
  112.             Node<E> next = x.next;
  113.             x.item = null;
  114.             x.next = null;
  115.             x.prev = null;
  116.             x = next;
  117.         }
  118.         first = last = null;
  119.         size = 0;
  120.         modCount++;
  121.     }


LinkedList查找
  1. //返回列表首节点元素值
  2.     public E getFirst() {
  3.         final Node<E> f = first;
  4.         if (f == null)  //如果首节点为null
  5.             throw new NoSuchElementException();
  6.         return f.item;
  7.     }
  9.     //返回列表尾节点元素值
  10.     public E getLast() {
  11.         final Node<E> l = last;
  12.         if (l == null) //如果尾节点为null
  13.             throw new NoSuchElementException();
  14.         return l.item;
  15.     }
  17.     //判断列表中是否包含有元素值o，返回true当列表中至少存在一个元素值e，使得(o==null?e==null:o.equals(e))
  18.     public boolean contains(Object o) {
  19.         return indexOf(o) != -1;
  20.     }
  22.     //返回指定索引处的元素值
  23.     public E get(int index) {
  24.         checkElementIndex(index); //index >= 0 && index < size
  25.         return node(index).item;  //node(index)返回指定索引位置index处的节点
  26.     }
  28.     //返回指定索引位置的节点
  29.     Node<E> node(int index) {
  30.         // assert isElementIndex(index);
  31.         //折半思想，当index < size/2时，从列表首节点向后查找
  32.         if (index < (size >> 1)) {
  33.             Node<E> x = first;
  34.             for (int i = 0; i < index; i++)
  35.                 x = x.next;
  36.             return x;
  37.         } else {  //当index >= size/2时，从列表尾节点向前查找
  38.             Node<E> x = last;
  39.             for (int i = size - 1; i > index; i--)
  40.                 x = x.prev;
  41.             return x;
  42.         }
  43.     }
  45.     //正向查找，返回LinkedList中元素值Object o第一次出现的位置，如果元素不存在，则返回-1
  46.     public int indexOf(Object o) {
  47.         int index = 0;
  48.         //由于LinkedList中允许存放null，因此下面通过两种情况来分别处理
  49.         if (o == null) {
  50.             for (Node<E> x = first; x != null; x = x.next) { //顺序向后
  51.                 if (x.item == null)
  52.                     return index;
  53.                 index++;
  54.             }
  55.         } else {
  56.             for (Node<E> x = first; x != null; x = x.next) {
  57.                 if (o.equals(x.item))
  58.                     return index;
  59.                 index++;
  60.             }
  61.         }
  62.         return -1;
  63.     }
  65.     //逆向查找，返回LinkedList中元素值Object o最后一次出现的位置，如果元素不存在，则返回-1
  66.     public int lastIndexOf(Object o) {
  67.         int index = size;
  68.         //由于LinkedList中允许存放null，因此下面通过两种情况来分别处理
  69.         if (o == null) {
  70.             for (Node<E> x = last; x != null; x = x.prev) {  //逆向向前
  71.                 index--;
  72.                 if (x.item == null)
  73.                     return index;
  74.             }
  75.         } else {
  76.             for (Node<E> x = last; x != null; x = x.prev) {
  77.                 index--;
  78.                 if (o.equals(x.item))
  79.                     return index;
  80.             }
  81.         }
  82.         return -1;
  83.     }


LinkedList的Queue操作
  1. //获取但不移除此队列的头；如果此队列为空，则返回 null
  2.     public E peek() {
  3.         final Node<E> f = first;
  4.         return (f == null) ? null : f.item;
  5.     }
  7.     //获取但不移除此队列的头；如果此队列为空，则抛出NoSuchElementException异常
  8.     public E element() {
  9.         return getFirst();
  10.     }
  12.     //获取并移除此队列的头，如果此队列为空，则返回 null
  13.     public E poll() {
  14.         final Node<E> f = first;
  15.         return (f == null) ? null : unlinkFirst(f);
  16.     }
  18.     //获取并移除此队列的头，如果此队列为空，则抛出NoSuchElementException异常
  19.     public E remove() {
  20.         return removeFirst();
  21.     }
  23.     //将指定的元素值(E e)插入此列表末尾
  24.     public boolean offer(E e) {
  25.         return add(e);
  26.     }


LinkedList的双端队列操作
  1. //获取但不移除此队列的头；如果此队列为空，则返回 null
  2.     public E peek() {
  3.         final Node<E> f = first;
  4.         return (f == null) ? null : f.item;
  5.     }
  7.     //获取但不移除此队列的头；如果此队列为空，则抛出NoSuchElementException异常
  8.     public E element() {
  9.         return getFirst();
  10.     }
  12.     //获取并移除此队列的头，如果此队列为空，则返回 null
  13.     public E poll() {
  14.         final Node<E> f = first;
  15.         return (f == null) ? null : unlinkFirst(f);
  16.     }
  18.     //获取并移除此队列的头，如果此队列为空，则抛出NoSuchElementException异常
  19.     public E remove() {
  20.         return removeFirst();
  21.     }
  23.     //将指定的元素值(E e)插入此列表末尾
  24.     public boolean offer(E e) {
  25.         return add(e);
  26.     }
  28.     // Deque operations
  30.     //将指定的元素插入此双端队列的开头
  31.     public boolean offerFirst(E e) {
  32.         addFirst(e);
  33.         return true;
  34.     }
  36.     //将指定的元素插入此双端队列的末尾
  37.     public boolean offerLast(E e) {
  38.         addLast(e);
  39.         return true;
  40.     }
  42.     //获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null
  43.     public E peekFirst() {
  44.         final Node<E> f = first;
  45.         return (f == null) ? null : f.item;
  46.      }
  48.     //获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null
  49.     public E peekLast() {
  50.         final Node<E> l = last;
  51.         return (l == null) ? null : l.item;
  52.     }
  54.     //获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null
  55.     public E pollFirst() {
  56.         final Node<E> f = first;
  57.         return (f == null) ? null : unlinkFirst(f);
  58.     }
  60.     //获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null
  61.     public E pollLast() {
  62.         final Node<E> l = last;
  63.         return (l == null) ? null : unlinkLast(l);
  64.     }
  66.     //将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部）
  67.     public void push(E e) {
  68.         addFirst(e);
  69.     }
  71.     //从此双端队列所表示的堆栈中弹出一个元素（换句话说，移除并返回此双端队列的头部）
  72.     public E pop() {
  73.         return removeFirst();
  74.     }
  76.     //从此双端队列移除第一次出现的指定元素，如果列表中不包含次元素，则没有任何改变
  77.     public boolean removeFirstOccurrence(Object o) {
  78.         return remove(o);
  79.     }
  81.     //从此双端队列移除最后一次出现的指定元素,如果列表中不包含次元素，则没有任何改变
  82.     public boolean removeLastOccurrence(Object o) {
  83.         //由于LinkedList中允许存放null，因此下面通过两种情况来分别处理
  84.         if (o == null) {
  85.             for (Node<E> x = last; x != null; x = x.prev) { //逆向向前
  86.                 if (x.item == null) {
  87.                     unlink(x);
  88.                     return true;
  89.                 }
  90.             }
  91.         } else {
  92.             for (Node<E> x = last; x != null; x = x.prev) {
  93.                 if (o.equals(x.item)) {
  94.                     unlink(x);
  95.                     return true;
  96.                 }
  97.             }
  98.         }
  99.         return false;
  100.     }
事实上，LinkedList的队列操作，最终都是转化为链表的操作。


LinkedList的Fail-Fast机制

LinkedList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

 
对addAll函数的思考
  1. public boolean addAll(int index, Collection<? extends E> c) {
  2.         checkPositionIndex(index);
  4.         Object[] a = c.toArray();
  5.         int numNew = a.length;
  6.         if (numNew == 0)
  7.             return false;
  9.         Node<E> pred, succ;
  10.         if (index == size) {
  11.             succ = null;
  12.             pred = last;
  13.         } else {
  14.             succ = node(index);
  15.             pred = succ.prev;
  16.         }
  18.         for (Object o : a) {
  19.             @SuppressWarnings("unchecked") E e = (E) o;
  20.             Node<E> newNode = new Node<>(pred, e, null);
  21.             if (pred == null)
  22.                 first = newNode;
  23.             else
  24.                 pred.next = newNode;
  25.             pred = newNode;
  26.         }
  28.         if (succ == null) {
  29.             last = pred;
  30.         } else {
  31.             pred.next = succ;
  32.             succ.prev = pred;
  33.         }
  35.         size += numNew;
  36.         modCount++;
  37.         return true;
  38.     }

在addAll函数中，传入一个集合参数和插入位置，然后将集合转化为数组，然后再遍历数组，挨个添加数组的元素，但是问题来了，为什么要先转化为数组再进行遍历，而不是直接遍历集合呢？从效果上两者是完全等价的，都可以达到遍历的效果。关于为什么要转化为数组的问题，我的思考如下：1. 如果直接遍历集合的话，那么在遍历过程中需要插入元素，在堆上分配内存空间，修改指针域，这个过程中就会一直占用着这个集合，考虑正确同步的话，其他线程只能一直等待。2. 如果转化为数组，只需要遍历集合，而遍历集合过程中不需要额外的操作，所以占用的时间相对是较短的，这样就利于其他线程尽快的使用这个集合。说白了，就是有利于提高多线程访问该集合的效率，尽可能短时间的阻塞。





阅读全文
1 0
mac系统格式化u盘 mac系统格式化u盘
原创粉丝点击
热门IT博客
htpc软件htpc软件
根网科技 知乎根网科技 知乎
樱桃初夏网络剧网盘
指针与一维数组
仿砍柴网源码破解版
网络棋牌游戏违法吗
法国娇蕊淘宝有卖的吗
python opencv hough
水果淘宝店铺介绍范文
阿瓦隆b族洗发水 知乎
手机淘宝账号是什么
最全小说软件
51单片机与stm32
手机优化软件哪个最好
js获取display属性
in软件怎么裁剪
js 形参和实参
淘宝3c认证是什么意思
java聊天室传文件
如何查询别人淘宝id
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 酱汁排骨饭 排骨饭如何做 冬菇排骨饭 菜远排骨饭 家常排骨饭 真功夫香汁排骨饭 招牌排骨饭 怎么做排骨饭 排骨精排骨饭 土豆排骨饭的做法 东北秘制排骨饭 排骨酱油饭 米哥排骨饭 排骨饭的简单做法 排骨饭热量 排骨炒饭 酱骨架的做法 排骨勾鸡的做法 掖庭宫花事 玉胡芦 掖组词 田中千绘 掘墓者 掘墓者怎样出装 掘墓者输出出装 掘墓者出装 掘墓者符文天赋 掘墓者约里克 如东县掘港镇 掘港镇 掘港 掘的组词有什么 掘怎么读音 掘进机截割头 掘进机切割头 掘进机图片 掘进机厂家 小型隧道掘进机 小型掘进机 全断面隧道掘进机 煤矿掘进机厂家 煤矿掘进机

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里