Java重要类之LinkedList
Posted 蓝天白云。
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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/详细说明
1 LinkedList的API
2 boolean add(E object) // 在链表/队列结尾添加元素
3 void add(int location, E object) // 在指定位置添加元素
4 boolean addAll(Collection<? extends E> collection) // 在链表结尾插入链表所有元素
5 boolean addAll(int location, Collection<? extends E> collection) // 在链表指定位置插入链表所有元素
6 void addFirst(E object) // 在链表开头添加元素
7 void addLast(E object) // 在链表结尾添加元素
8 void clear()//清空链表
9 Object clone()//浅拷贝，与原链表共享对象
10 boolean contains(Object object) //是否包含某元素
11 Iterator<E> descendingIterator()
12 E element()//返回此链表/队列第一个元素但不删除
13 E get(int location)//获取指定位置的元素
14 E getFirst()//返回此链表第一个元素
15 E getLast()//返回此链表最后一个元素
16 int indexOf(Object object)//返回指定元素的第一个匹配项的索引在此列表中，或者如果此列表中不包含该元素返回-1
17 int lastIndexOf(Object object)//返回指定元素的最后一个匹配项的索引在此列表中，或者如果此列表中不包含该元素返回-1
18 ListIterator<E> listIterator(int location)
19 boolean offer(E o) // 在队列的末尾插入指定的元素
20 boolean offerFirst(E e) // 在此列表的开头插入指定的元素
21 boolean offerLast(E e)// 在此列表的末尾插入指定的元素
22 E peek()//访问此链表/列表/栈第一个元素但不删除
23 E peekFirst()//返回此链表第一个元素但不删除
24 E peekLast()//返回此链表最后一个元素但不删除
25 E poll()//检索并移除头部
26 E pollFirst()//检索并移除头部
27 E pollLast()//检索并移除最后一个元素
28 E pop() // 从此列表所表示的堆栈处弹出一个元素（获取并移除列表第一个元素）
29 void push(E e) // 将元素推入此列表所表示的堆栈（插入到列表的头）
30 E remove() //删除队列第一个元素
31 E remove(int location)//删除指定位置的元素
32 boolean remove(Object object)//删除指定元素
33 E removeFirst() // 从此列表中移除第一个元素
34 boolean removeFirstOccurrence(Object o) // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表）
35 E removeLast()// 从此列表中移除最后一个元素
36 boolean removeLastOccurrence(Object o) // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表）
37 E set(int location, E object) // 将此列表中指定位置的元素替换为指定的元素
38 int size()//链表大小
39 <T> T[] toArray(T[] contents)
40 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、迭代器遍历
1 Iterator<Integer> iterator = linkedList.iterator();
2 while(iterator.hasNext()){
3 iterator.next();
4 }
2、get遍历
对linkedList进行顺序遍历速度较慢，每一次get都需要从头开始搜索
1 for(int i = 0; i < linkedList.size(); i++){
2 linkedList.get(i);
3 }
3、for遍历
1 for(Integer i:linklist){
2 System.out.println(i);
3 }
4、遍历的同时删除元素
1 while(linklist.size() != 0){
2 linklist.pollFirst(); // linklist.pollLast();
3 }
1 while(linklist.size() != 0){
2 linklist.removeFirst(); // linklist.removeLast();
3 }
综上以上几种方式，第2种效率最低，尽量不采用。如果是单纯的访问元素，避免对原链表的修改，则使用方式1或3。注意：方式4在访问链表元素的同时会删除元素。
五、LinkedList源码
具体说明参考博客https://blog.csdn.net/qq_19431333/article/details/54572876
1 package java.util; 2 3 public class LinkedList<E> 4 extends AbstractSequentialList<E> 5 implements List<E>, Deque<E>, Cloneable, java.io.Serializable 6 { 7 // 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。 8 private transient Entry<E> header = new Entry<E>(null, null, null); 9 10 // LinkedList中元素个数 11 private transient int size = 0; 12 13 // 默认构造函数：创建一个空的链表 14 public LinkedList() { 15 header.next = header.previous = header; 16 } 17 18 // 包含“集合”的构造函数:创建一个包含“集合”的LinkedList 19 public LinkedList(Collection<? extends E> c) { 20 this(); 21 addAll(c); 22 } 23 24 // 获取LinkedList的第一个元素 25 public E getFirst() { 26 if (size==0) 27 throw new NoSuchElementException(); 28 29 // 链表的表头header中不包含数据。 30 // 这里返回header所指下一个节点所包含的数据。 31 return header.next.element; 32 } 33 34 // 获取LinkedList的最后一个元素 35 public E getLast() { 36 if (size==0) 37 throw new NoSuchElementException(); 38 39 // 由于LinkedList是双向链表；而表头header不包含数据。 40 // 因而，这里返回表头header的前一个节点所包含的数据。 41 return header.previous.element; 42 } 43 44 // 删除LinkedList的第一个元素 45 public E removeFirst() { 46 return remove(header.next); 47 } 48 49 // 删除LinkedList的最后一个元素 50 public E removeLast() { 51 return remove(header.previous); 52 } 53 54 // 将元素添加到LinkedList的起始位置 55 public void addFirst(E e) { 56 addBefore(e, header.next); 57 } 58 59 // 将元素添加到LinkedList的结束位置 60 public void addLast(E e) { 61 addBefore(e, header); 62 } 63 64 // 判断LinkedList是否包含元素(o) 65 public boolean contains(Object o) { 66 return indexOf(o) != -1; 67 } 68 69 // 返回LinkedList的大小 70 public int size() { 71 return size; 72 } 73 74 // 将元素(E)添加到LinkedList中 75 public boolean add(E e) { 76 // 将节点(节点数据是e)添加到表头(header)之前。 77 // 即，将节点添加到双向链表的末端。 78 addBefore(e, header); 79 return true; 80 } 81 82 // 从LinkedList中删除元素(o) 83 // 从链表开始查找，如存在元素(o)则删除该元素并返回true； 84 // 否则，返回false。 85 public boolean remove(Object o) { 86 if (o==null) { 87 // 若o为null的删除情况 88 for (Entry<E> e = header.next; e != header; e = e.next) { 89 if (e.element==null) { 90 remove(e); 91 return true; 92 } 93 } 94 } else { 95 // 若o不为null的删除情况 96 for (Entry<E> e = header.next; e != header; e = e.next) { 97 if (o.equals(e.element)) { 98 remove(e); 99 return true; 100 } 101 } 102 } 103 return false; 104 } 105 106 // 将“集合(c)”添加到LinkedList中。 107 // 实际上，是从双向链表的末尾开始，将“集合(c)”添加到双向链表中。 108 public boolean addAll(Collection<? extends E> c) { 109 return addAll(size, c); 110 } 111 112 // 从双向链表的index开始，将“集合(c)”添加到双向链表中。 113 public boolean addAll(int index, Collection<? extends E> c) { 114 if (index < 0 || index > size) 115 throw new IndexOutOfBoundsException("Index: "+index+ 116 ", Size: "+size); 117 Object[] a = c.toArray(); 118 // 获取集合的长度 119 int numNew = a.length; 120 if (numNew==0) 121 return false; 122 modCount++; 123 124 // 设置“当前要插入节点的后一个节点” 125 Entry<E> successor = (index==size ? header : entry(index)); 126 // 设置“当前要插入节点的前一个节点” 127 Entry<E> predecessor = successor.previous; 128 // 将集合(c)全部插入双向链表中 129 for (int i=0; i<numNew; i++) { 130 Entry<E> e = new Entry<E>((E)a[i], successor, predecessor); 131 predecessor.next = e; 132 predecessor = e; 133 } 134 successor.previous = predecessor; 135 136 // 调整LinkedList的实际大小 137 size += numNew; 138 return true; 139 } 140 141 // 清空双向链表 142 public void clear() { 143 Entry<E> e = header.next; 144 // 从表头开始，逐个向后遍历；对遍历到的节点执行一下操作： 145 // (01) 设置前一个节点为null 146 // (02) 设置当前节点的内容为null 147 // (03) 设置后一个节点为“新的当前节点” 148 while (e != header) { 149 Entry<E> next = e.next; 150 e.next = e.previous = null; 151 e.element = null; 152 e = next; 153 } 154 header.next = header.previous = header; 155 // 设置大小为0 156 size = 0; 157 modCount++; 158 } 159 160 // 返回LinkedList指定位置的元素 161 public E get(int index) { 162 return entry(index).element; 163 } 164 165 // 设置index位置对应的节点的值为element 166 public E set(int index, E element) { 167 Entry<E> e = entry(index); 168 E oldVal = e.element; 169 e.element = element; 170 return oldVal; 171 } 172 173 // 在index前添加节点，且节点的值为element 174 public void add(int index, E element) { 175 addBefore(element, (index==size ? header : entry(index))); 176 } 177 178 // 删除index位置的节点 179 public E remove(int index) { 180 return remove(entry(index)); 181 } 182 183 // 获取双向链表中指定位置的节点 184 private Entry<E> entry(int index) { 185 if (index < 0 || index >= size) 186 throw new IndexOutOfBoundsException("Index: "+index+ 187 ", Size: "+size); 188 Entry<E> e = header; 189 // 获取index处的节点。 190 // 若index < 双向链表长度的1/2,则从前先后查找; 191 // 否则，从后向前查找。 192 if (index < (size >> 1)) { 193 for (int i = 0; i <= index; i++) 194 e = e.next; 195 } else { 196 for (int i = size; i > index; i--) 197 e = e.previous; 198 } 199 return e; 200 } 201 202 // 从前向后查找，返回“值为对象(o)的节点对应的索引” 203 // 不存在就返回-1 204 public int indexOf(Object o) { 205 int index = 0; 206 if (o==null) { 207 for (Entry e = header.next; e != header; e = e.next) { 208 if (e.element==null) 209 return index; 210 index++; 211 } 212 } else { 213 for (Entry e = header.next; e != header; e = e.next) { 214 if (o.equals(e.element)) 215 return index; 216 index++; 217 } 218 } 219 return -1; 220 } 221 222 // 从后向前查找，返回“值为对象(o)的节点对应的索引” 223 // 不存在就返回-1 224 public int lastIndexOf(Object o) { 225 int index = size; 226 if (o==null) { 227 for (Entry e = header.previous; e != header; e = e.previous) { 228 index--; 229 if (e.element==null) 230 return index; 231 } 232 } else { 233 for (Entry e = header.previous; e != header; e = e.previous) { 234 index--; 235 if (o.equals(e.element)) 236 return index; 237 } 238 } 239 return -1; 240 } 241 242 // 返回第一个节点 243 // 若LinkedList的大小为0,则返回null 244 public E peek() { 245 if (size==0) 246 return null; 247 return getFirst(); 248 } 249 250 // 返回第一个节点 251 // 若LinkedList的大小为0,则抛出异常 252 public E element() { 253 return getFirst(); 254 } 255 256 // 删除并返回第一个节点 257 // 若LinkedList的大小为0,则返回null 258 public E poll() { 259 if (size==0) 260 return null; 261 return removeFirst(); 262 } 263 264 // 将e添加双向链表末尾 265 public boolean offer(E e) { 266 return add(e); 267 } 268 269 // 将e添加双向链表开头 270 public boolean offerFirst(E e) { 271 addFirst(e); 272 return true; 273 } 274 275 // 将e添加双向链表末尾 276 public boolean offerLast(E e) { 277 addLast(e); 278 return true; 279 } 280 281 // 返回第一个节点 282 // 若LinkedList的大小为0,则返回null 283 public E peekFirst() { 284 if (size==0) 285 return null; 286 return getFirst(); 287 } 288 289 /以上是关于Java重要类之LinkedList的主要内容，如果未能解决你的问题，请参考以下文章