Java集合之List：LinkedList

继承及实现接口关系

继承抽象类：

AbstractSequentialList：该抽象类继承自AbstractList，仅支持按次序访问

实现接口：

1. List
2. Deque（使得LinkedList可以作为双向队列使用）
3. Cloneable（标志 只有实现该接口才可以重写Object中的clone方法）
4. Serializable(标志 表示当前类对象可以序列化，可以使用关键字transient区别字段不需要被序列化)

底层实现

// 头节点
transient Node<E> first;
// 尾节点
transient Node<E> last;

        底层是双向链表，由字段first、last两个Node实现。

        其中Node类实现在LinkedList类中，包括三个字段：item(元素值)、next(下一个节点)、prev(前一个节点)；一个初始化方法Node(Node<E> prev, E element, Node<E> next)

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

使用场景

        循环迭代访问某些元素；在不定位置频繁插入、删除元素

初始化方法

// 共2种
// 空方法
public LinkedList();
// 将集合c中元素添加至当前LinkedList中
public LinkedList(Collection<? extends E> c);

主要方法

// 获取第一个元素。若没有则抛出异常，有则返回元素值
public E getFirst();
public E element();
// 获取最后一个元素。若没有则抛出异常，有则返回元素值
public E getLast();
// 移除第一个元素。首先检查first节点是否存在，存在后将first删除并后移一位，返回被删除元素值
public E removeFirst();
public E remove();
public E pop();
// 移除最后一个元素。首先检查last节点是否存在，存在后将last删除并前移一位，返回被删除元素值
public E removeLast();
// 在头位置插入元素。将新元素插入后置为first，原first的前一个节点指向新first
public void addFirst(E e);
public boolean offerFirst(E e);
public void push(E e);
// 在尾处插入元素。将新元素插入后置为last，原last的后一个节点指向新last
public void addLast(E e);
public boolean offerLast(E e)
// 是否包含元素o。调用方法indexOf（获取所给元素在list中的下标）判断返回值是否为-1
public boolean contains(Object o);
// 当前list中元素数量
public int size();
// 在尾部插入元素
public boolean add(E e);
public boolean offer(E e);
// 移除list中首次出现的元素o，若为null则删除首个为null的元素
public boolean remove(Object o);
// 将c中元素全部插入当前list之后
public boolean addAll(Collection<? extends E> c);
// 在当前list的index下标处插入c中所有元素，原元素全部后移
public boolean addAll(int index, Collection<? extends E> c);
// 清空当前list。将当前list中所有节点置为null
public void clear();
// 获取index下标处元素
public E get(int index);
// 在index下标处插入元素element
public E set(int index, E element);
// 在index处插入元素
public void add(int index, E element);
// 移除index位置处元素
public E remove(int index);
// 获取首个元素o的位置
public int indexOf(Object o);
// 获取最后一个元素o的位置
public int lastIndexOf(Object o);
// 移除首个出现的元素o
public boolean removeFirstOccurrence(Object o);
// 移除最后一个出现的元素o
public boolean removeLastOccurrence(Object o);
// 获取头元素，若没有则为null
public E peek();
public E peekFirst();
// 获取尾元素，若没有则为null
public E peekLast();
// 移除首个元素，没有返回null
public E poll();
public E pollFirst();
// 移除尾元素，若没有则为null
public E pollLast();
// 转换为数组
public Object[] toArray();
// 转换为数组a并返回
public <T> T[] toArray(T[] a);
// 迭代器
for(Iterator<Integer> it=list.iterator(); it.hasNext(); )
    it.next();
// foreach
foreach(Integer i:list)

LinkedList的使用

作为双端队列

// 在前后插入元素并返回元素值
E addFirst(E e);
E addLast(E e);
// 在前后插入元素并返回插入是否成功
boolean offerFirst(E e);
boolean offerLast(E e);
// 删除首尾元素并返回被删除元素值
E removeFirst();
E removeLast();
// 移除首尾元素并返回被移除元素
E pollFirst();
E pollLast();
// 获取首尾元素
E getFirst();
E getLast();
// 获取首尾元素
E peekFirst();
E peekLast();

作为队列（单向，先进先出）使用

// 在尾部添加元素
boolean add(E e);
// 在尾部添加元素
boolean offer(E e);
// 移除首部元素并返回该元素
E remove();
E poll();
// 获取首部元素
E element();

作为栈使用

// 获取栈顶元素
E peek();
// 向栈中加入元素
void push(E e);
// 删除栈顶元素并返回元素
E pop();