一、 LinkedList简介
LinkedList 跟 ArrayList一样实现了List接口,但跟ArrayList不同的是ArrayList采用的是数组作为存储元素的容器,所以ArrayList可以直接用下标获取元素,所以ArrayList查询效率较高, 但在添加和删除元素的速度比较慢,因为得需要移动元素。而LinkedList采用的是链表来存储元素, 因为它没有下标,所以在查询某个元素时的速度较慢,需要遍历链表,但在添加和删除元素时不用移动其他元素,所以增删速度快。
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable
类的继承结构如下:
二、 LinkedList的数据结构
1. LinkedList结构图
Linked中的每个节点都包含了上一个元素和下一个元素,如果该节点为头节点的话,该节点就只有下一个元素,如果该节点是尾节点的话,name该节点只有上一个元素
node表示如下
private static class Node<E> { E item;// 当前节点存储元素 Node<E> next;// 下一个节点 Node<E> prev;// 上一个节点 }
2. LinkedList增删图
三、LinkedList源码解析
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { // 链表中元素的个数 transient int size = 0; // 链表的第一个节点 transient Node<E> first; // 链表的最后一个节点 transient Node<E> last; // 空参数构造函数 public LinkedList() { } // 参数为Collection的构造函数,将另外一个集合的元素添加都链表中 public LinkedList(Collection<? extends E> c) { this(); addAll(c); } // 往链表头部加入一个元素 private void linkFirst(E e) { //获取当前链表的头 final Node<E> f = first; // 创建一个节点,因为该节点要放到头部, //所以该节点的上一个节点为null,而下一个节点就是原来链表的头 final Node<E> newNode = new Node<>(null, e, f); // 将新节点赋值给first first = newNode; // 如果原来节点的first为空,说明原来链表没有节点,所以尾节点也等于新节点 if (f == null) last = newNode; else // 否则将原来的头节点的上一个节点赋值为新的头节点 f.prev = newNode; // 链表中元素 + 1 size++; // 修改次数 + 1 modCount++; } // 往链表尾部加入一个元素,与上面类似 void linkLast(E e) { final Node<E> l = last; // 新添加的尾节点的上一个节点是原来链表的尾节点,而下一个节点是null final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; } // 在某个节点之前添加一个节点 void linkBefore(E e, Node<E> succ) { // 获取succ节点原来的上一个节点 final Node<E> pred = succ.prev; // 新加节点的上一个节点为原来succ的上一个节点,而下一个节点则为 succ final Node<E> newNode = new Node<>(pred, e, succ); succ.prev = newNode; if (pred == null) first = newNode; else pred.next = newNode; size++; modCount++; } // 删除头节点 private E unlinkFirst(Node<E> f) { // assert f == first && f != null; final E element = f.item; final Node<E> next = f.next; // 将要删除的头节点的元素和下一个元素置为null,下一次垃圾回收就会回收掉 f.item = null; f.next = null; // help GC //将头节点设为原来链表的第二个节点 first = next; if (next == null) last = null; else next.prev = null; size--; modCount++; // 返回删掉的节点的元素 return element; } // 移除最后一个节点,与上类似 private E unlinkLast(Node<E> l) { // assert l == last && l != null; final E element = l.item; final Node<E> prev = l.prev; l.item = null; l.prev = null; // help GC last = prev; if (prev == null) first = null; else prev.next = null; size--; modCount++; return element; } // 删除某一个节点 E unlink(Node<E> x) { // assert x != null; final E element = x.item; final Node<E> next = x.next; final Node<E> prev = x.prev; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } x.item = null; size--; modCount++; return element; } // 获取第一个节点的元素 public E getFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return f.item; } // 获取最后一个节点的元素 public E getLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return l.item; } // 移除第一个节点 public E removeFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return unlinkFirst(f); } // 移除最后一个节点 public E removeLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return unlinkLast(l); } // 往头部添加节点 public void addFirst(E e) { linkFirst(e); } //往尾部添加节点 public void addLast(E e) { linkLast(e); } // 判断该链表是否包含某个元素 public boolean contains(Object o) { return indexOf(o) != -1; } // 判断该链表是否包含某个元素 public int size() { return size; } // 添加节点,则往尾部添加节点,所以链表的添加都是往尾部添加元素 public boolean add(E e) { linkLast(e); return true; } // 移除某个节点,成功返回true,否则false public boolean remove(Object o) { if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) { unlink(x); return true; } } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; } //将另外一个集合中的元素添加到链表的尾部 public boolean addAll(Collection<? extends E> c) { return addAll(size, c); } // 将另外一个集合中的元素添加到链表指点的某个位置 public boolean addAll(int index, Collection<? extends E> c) { checkPositionIndex(index); Object[] a = c.toArray(); int numNew = a.length; if (numNew == 0) return false; Node<E> pred, succ; if (index == size) { succ = null; pred = last; } else { succ = node(index); pred = succ.prev; } for (Object o : a) { @SuppressWarnings("unchecked") E e = (E) o; Node<E> newNode = new Node<>(pred, e, null); if (pred == null) first = newNode; else pred.next = newNode; pred = newNode; } if (succ == null) { last = pred; } else { pred.next = succ; succ.prev = pred; } size += numNew; modCount++; return true; } // 清空链表 public void clear() { for (Node<E> x = first; x != null; ) { Node<E> next = x.next; x.item = null; x.next = null; x.prev = null; x = next; } first = last = null; size = 0; modCount++; } // 通过给定位置获取元素 public E get(int index) { //判断是否下标越界 checkElementIndex(index); return node(index).item; } // 修改某个节点的元素 public E set(int index, E element) { checkElementIndex(index); Node<E> x = node(index); E oldVal = x.item; x.item = element; return oldVal; } // 往某个位置添加元素 public void add(int index, E element) { checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); } // 移除掉某个位置的元素 public E remove(int index) { //判断是否下标越界 checkElementIndex(index); return unlink(node(index)); } // 检查元素下标 private void checkElementIndex(int index) { if (!isElementIndex(index)) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } // 通过下标查找节点 Node<E> node(int index) { // size >> 1 = size / 2 取链表的中间值位置, 目的:优化查找速度 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; } } // 获取某个元素在链表的位置,获取不到返回 -1 链表是否包含元素会用到此方法 public int indexOf(Object o) { int index = 0; if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; } }
四、总结
LinkedList源码也比较简单,LinkedList适合插入删除,ArrayList适合查找,后面要介绍的HashMap就是用LinkedList和ArrayList的数据结构实现的,和ArrayList一样都是线程非安全的。