Java基础之容器LinkedList

一、LinkedList的整体结构

1.1、LinkedList的继承关系

• public class LinkedList<E> extends AbstractSequentialList <E> implements List<E>, Deque<E>
• LinkedList具备AbstractSequentialList的特点：AbstractSequentialList 只支持按次序访问，而不像 AbstractList 那样支持随机访问
• LinkedList具备List的特点
• LinkedList具备Deque的特点：Deque是一个线性collection，支持在两端插入和移除元素

1.2、LinkedList的结构

1. //元素个数
2. transient int size = 0;
3. //第一个元素指针
4. transient Node<E> first;
5. //最后一个元素指针
6. transient Node<E> last;
7. //Node节点的结构
8. private static class Node<E> {
9. E item;//当前元素
10. Node<E> next;//当前元素的下一个指针
11. Node<E> prev;//当前元素的上一个指针
12. Node(Node<E> prev, E element, Node<E> next) {
13. this.item = element;
14. this.next = next;
15. this.prev = prev;
16. }
17. }

1.2.1 Node的结构

LinkedList结构

LinkedList特点

1.LinkedList是通过双链表去实现的。

2.LinkedList不存在容量不足的问题，因为是链表。

3.LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法，所以LinkedList可以作为FIFO（先进先出）的队列；LinkedList可以作为LIFO（后进先出）的栈

二、源码分析

2.1、添加元素

1. //添加元素
2. public boolean add(E e) {
3. //默认调用，尾部添加元素的方法
4. linkLast(e);
5. return true;
6. }
7. //尾部添加元素
8. void linkLast(E e) {
9. //记录当前尾部元素
10. final Node<E> l = last;
11. //创建一个新的Node节点 ，prev是当前的尾节点，next指向null
12. final Node<E> newNode = new Node<>(l, e, null);
13. //将last设置为新节点
14. last = newNode;
15. //判断当前尾部节点是否为null
16. if (l == null)
17. //当前尾部节点为null，就挂到头结点上
18. first = newNode;
19. else
20. //当前尾部节点不为null，就将新建的Node挂到当前last节点的next指针上
21. l.next = newNode;
22. //元素的个数+1
23. size++;
24. //LinkedList修改记录+1
25. modCount++;
26. }

新增元素add()方法默认是尾部追加，核心就是将新建的Node节点追加到当前last节点的next指针上 ，伪代码：

1. Node newNode=new Node();
2. newNode.prev=last;
3. last.next=newNode;
4. last=newNode;
5. last.next=null;

addFirst：首部追加

1. public void addFirst(E e) {
2. linkFirst(e);
3. }
4. //头部追加
5. private void linkFirst(E e) {
6. //记录当前首部元素
7. final Node<E> f = first;
8. //新建一个Node节点
9. final Node<E> newNode = new Node<>(null, e, f);
10. //首部元素指向新建的节点
11. first = newNode;
12. //判断当前首部指针是否为null
13. if (f == null)
14. //当前首部指针为null,就把新建的节点挂到last指针上
15. last = newNode;
16. else
17. //当前首部指针不为null,就把新建的节点挂到，当前first指针指向元素的prev指针上
18. f.prev = newNode;
19. //元素个数+1
20. size++;
21. //LinkedList修改记录+1
22. modCount++;
23. }

首部追加的逻辑与尾部追加基本相同，伪代码：

1. Node newNode=new Node();
2. newNode.next=first;
3. first.prev=newNode;
4. first=newNode;
5. first.prev=null;(也可以：newNode.prev=null)

指定位置添加元素：add(int index, E element)：

1. public void add(int index, E element) {
2. //检查要插入的位置是否合法
3. checkPositionIndex(index);
4. //如要插入的位置在最后，直接调用linkLast()
5. if (index == size)
6. linkLast(element);
7. else
8. //如要插入的位置不在最后，就先查找再插入
9. linkBefore(element, node(index));
10. }
11.  
12. //查找要插入元素的位置
13. Node<E> node(int index) {
14. // assert isElementIndex(index);
15. //如果要插入的位置小于集合的一半，我就从头开始找
16. if (index < (size >> 1)) {
17. Node<E> x = first;
18. for (int i = 0; i < index; i++)
19. x = x.next;
20. return x;
21. } else {
22. //如果要插入的位置大于等于集合的一半，我就从尾部开始找
23. Node<E> x = last;
24. for (int i = size - 1; i > index; i--)
25. x = x.prev;
26. return x;
27. }
28. }
29. //将新建的元素插入到查找的元素前面
30. void linkBefore(E e, Node<E> succ) {
31. // assert succ != null;
32. final Node<E> pred = succ.prev;
33. final Node<E> newNode = new Node<>(pred, e, succ);
34. succ.prev = newNode;
35. if (pred == null)
36. first = newNode;
37. else
38. pred.next = newNode;
39. size++;
40. modCount++;
41. }

LinkedList是一个双向链表，他只记录了头部和尾部位置，如果我们要指定位置插入，他会这么做：

1.先遍历查找出要插入的元素位置，然后再插入；查找方式是根据 index < (size >> 1) 判断结果，决定是从头遍历，还是从尾部遍历，这种遍历方式类似于二分查找(只在第一层循环二分)

2.新建一个Node节点，插入到查找出来的元素的前面

由此可知为何链表对随机位置读写是不合适的；他的时间复杂度=O(n/2) ，如果n很大，我们一般就认为他的时间复杂度=O(n)

2.2、删除元素

1. //重写List的remove()
2. public boolean remove(Object o) {
3. if (o == null) {
4. //如果要删除的元素null元素,从头开始查找这个null元素
5. for (Node<E> x = first; x != null; x = x.next) {
6. if (x.item == null) {
7. unlink(x);
8. return true;
9. }
10. }
11. } else {
12. //如果要删除的元素不null元素,从头开始查找这个非null元素
13. for (Node<E> x = first; x != null; x = x.next) {
14. if (o.equals(x.item)) {
15. unlink(x);
16. return true;
17. }
18. }
19. }
20. return false;
21. }
22. //执行删除逻辑，实质就是打断改元素与链表的引用关系
23. E unlink(Node<E> x) {
24. // assert x != null;
25. //记录改元素的值，实际作用就是做返回值
26. final E element = x.item;
27. //记录当前元素的下一个节点
28. final Node<E> next = x.next;
29. //记录当前元素的上一个节点
30. final Node<E> prev = x.prev;
31. //判断 x->prev 节点是否为null，为null就是删除头结点
32. if (prev == null) {
33. first = next;
34. } else {
35. //将 x->prev节点的next指针指向x节点的下一个节点
36. prev.next = next;
37. //将 x->prev 指针，设置为null(断开引用关系)
38. x.prev = null;
39. }
40. //判断 x->next 节点是否为null，为null就是删尾部结点
41. if (next == null) {
42. last = prev;
43. } else {
44. //将x->next节点的prev指针指向x->prev
45. next.prev = prev;
46. //将 x->next指针，设置为null(断开引用关系)
47. x.next = null;
48. }
49. //将x的值设置为null
50. x.item = null;
51. //集合大小-1
52. size--;
53. //集合的修改记录-1
54. modCount++;
55. return element;
56. }

这里我们看到LinkedList重写了List的remove方法，整个删除逻辑也是先查找再删除，时间复杂度O(n)，如果是删除首部元素时间复杂度=O(1)，若要删除尾部元素请使用removeLast( )

• LinkedLis删除首部元素：removeFirst()
• LinkedLis删除尾部元素：removeLast()
• LinkedLis首部出队：pollFirst( ) ，队列的特点
• LinkedLit尾部出队：pollLast( )，队列的特点

2.3、迭代器

Iterator迭代器只能是从头往尾迭代，而LinkedList是双向链表，他还可以从尾往头部迭代，JAVA提供了一个新的迭代器接口：

1. public interface ListIterator<E> extends Iterator<E>{
2. //判断是否存在下一个元素
3. boolean hasNext();
4. //获取下一个元素
5. E next();
6. //判断是否还有前一个元素
7. boolean hasPrevious();
8. //获取前一个元素
9. E previous();
10. }

LinkedList实现该接口：

1. private class ListItr implements ListIterator<E> {
2. private Node<E> lastReturned;//上一次next() 或者 previous()的元素
3. private Node<E> next;//lastReturned->next 指向的元素
4. private int nextIndex;//下一个元素的位置
5. private int expectedModCount = modCount;
6. }

LinkedList从前往后遍历：

1. //是否存在下一个元素
2. public boolean hasNext() {
3. return nextIndex < size;
4. }
5. public E next() {
6. //检查集合的版本
7. checkForComodification();
8. if (!hasNext())
9. throw new NoSuchElementException();
10. //lastReturned赋值上次next
11. lastReturned = next;
12. //next赋值为上次next->next
13. next = next.next;
14. //下一个元素的位置
15. nextIndex++;
16. return lastReturned.item;
17. }

LinkedList从后往前遍历：

1. //判断是否到头了
2. public boolean hasPrevious() {
3. return nextIndex > 0;
4. }
5. //从尾部往头部取数据
6. public E previous() {
7. checkForComodification();
8. if (!hasPrevious())
9. throw new NoSuchElementException();
10. // next==null：第一次遍历取尾节点(last)，或者上一次遍历时把尾节点删除掉了
11. // next!=null：已经发生过遍历了，直接取前一个节点即可(next.prev)
12. lastReturned = next = (next == null) ? last : next.prev;
13. //遍历的指针-1
14. nextIndex--;
15. return lastReturned.item;
16. }

迭代器删除元素：

1. public void remove() {
2. checkForComodification();
3. // lastReturned 是本次迭代需要删除的值
4. // lastReturned==null则调用者没有主动执行过 next() 或者 previos()，二直接调remove()
5. // lastReturned!=null，是在上次执行 next() 或者 previos()方法时赋的值
6. if (lastReturned == null)
7. throw new IllegalStateException();
8. //保存将当前要删除节点的下一个节点(如果是从尾往头遍历，该值永远是null)
9. Node<E> lastNext = lastReturned.next;
10. //删除当前节点
11. unlink(lastReturned);
12.  
13. // next == lastReturned：从尾到头递归顺序，并且是第一次迭代，并且要删除最后一个元素的情况下，
14. // previous() 方法里面设置了 lastReturned = next = last,所以 next 和 lastReturned会相等
15. if (next == lastReturned)
16. next = lastNext;
17. else
18. nextIndex--;
19. lastReturned = null;
20. expectedModCount++;
21. }

三、总结

LinkedList底层数据结构是双向链表，所以他更适合顺序操作，由于他继承了Deque接口，同时他具有队列的性质，非线程安全的集合

到此这篇关于Java基础之容器LinkedList的文章就介绍到这了,更多相关Java容器LinkedList内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/jalja365/article/details/110489547