【Java集合源码解析】LinkedList

通过阅读源码 熟悉API-LinkedList-基于jdk1.8

描述

1. 基于内部类Node实现

增加

public void addFirst(E e){
    //只将原来的first的前一个连接到新节点
    //没有将新节点的后一个连接原节点
    final Node<E> f = first;
    f.prev = newNode;
}
public void addLast(E e){
    final Node<E> l = last;
    //不为null，将老节点后一个进行连接
    l.next = newNode;
}
//追加至末尾，与addLast相同
public boolean add(E e)
//追加至末尾，与add相同
public boolean offer(E e)
//调用addFirst
public boolean offerFirst(E e) 
//调用addLast
public boolean offerLast(E e)
//追加至末尾，与add相同
public void push(E e)

public boolean addAll(int index, Collection<? extends E> c){
        if (index == size) {
            //追加至最后，将当前最后一个座位pred
            succ = null;
            pred = last;
        } else {
            //找到索引为index的节点
            succ = node(index);
            pred = succ.prev;
        }
        for (Object o : a) {
            E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                //指定的索引所在节点为first，所有pred为null
                //将新的节点作为first
                first = newNode;
            else
                //将新节点作为指定索引前一个节点的下一个节点
                //即将新节点放置在指定索引节点的前面
                pred.next = newNode;
            //新节点作为前一个节点
            //继续添加新节点的时候，是放在同一个集合的节点的后面
            //指定索引节点的前面
            pred = newNode;
        }
        //在循环后，pred已经是要添加的最新的节点了
        if (succ == null) {
            //索引位置的节点为null,则需要在最后将集合进行追加
            //集合中最后遍历到的元素就是last
            //pred在前面的循环中已经确定，是要添加的最新node
            last = pred;
        } else {
            //索引指定位置的节点为最后添加的节点的下一个
            pred.next = succ;
            //同理，指定位置的节点的前一个，也即为当前节点
            succ.prev = pred;
        }
}
//追加至末尾，与上addAll相同
public boolean addAll(Collection<? extends E> c)

public void add(int index, E element){
        if (index == size)
            //指定位置为链表长度，则将元素追加至最后
            linkLast(element);
        else
            //插入在指定索引的非空节点前面
            linkBefore(element, node(index));
}

删除

private E unlinkFirst(Node<E> f){
        if (next == null)
            //如果一下一个为null，说明链表只有一个元素
            //则将链表的最后一个也至为null
            last = null;
        else
            //如果存在下一个，则将下一个的前一个至为null，即断链
            next.prev = null;
}
//第一个节点不为null,则调用unlinkFirst将其断连
public E removeFirst()
//调用unlinkLast，与unlinkLast同理
public E removeLast()
public boolean remove(Object o){
    //如果o为null，则将链表中找到的第一个item为null的元素移除
    //否则移除第一个值为o的元素
    //通过调用unlink进行断链
}
public void clear(){
    for (Node<E> x = first; x != null; ) {
        Node<E> next = x.next;
        //通过循环，从first开始，将所有节点置为null
        //同时先将next节点作为下一次的循环操作的节点x
        x = next;
    }
}
public E remove(int index){
    //根据索引获取到指定节点
    node(index)
    //再通过unlink进行断链
}
//调用removeFirst，即从链表首移除元素
public E remove()
//调用remove(Object o)，即从左到有，移除第一个与o相等的元素
public boolean removeFirstOccurrence(Object o)

public boolean removeLastOccurrence(Object o){
    //从最后一个节点向前循环就，移除发现的第一个元素
    for (Node<E> x = last; x != null; x = x.prev) {
        if (x.item == null) {
            unlink(x);
            return true;
        }
    }
}

修改

public E set(int index, E element){
    //通过node()找到节点后，直接将其item置为指定值
    x.item = element;
}

查找

//如果first节点不为null，则返回first节点
public E getFirst()
//如果last节点不为null，则返回last节点
public E getLast()
//调用indexOf(o)查找链表中是否存在有等于某个值的元素
public boolean contains(Object o)
//校验索引是否合法后，通过node(index)返回元素的值(item)
public E get(int index)
//循环判断后进行返回索引值，没有找到返回-1
public int indexOf(Object o) 
public int lastIndexOf(Object o)
//检索获取链表第一个头元素，不移除它
//如果为null则返回null
public E peek()
//检索获取链表第一个头元素，不移除它
//如果为null则抛出NoSuchElementException
public E element()
//与peek相同
public E peekFirst()
//检索获取链表最后一个元素，不移除它
//如果为null则返回null
public E peekLast()
//检索获取第一个元素，并移除它
//如果为null，则返回null
public E poll()
//与poll相同
public E pollFirst()
//检索获取第一个元素，并移除它
//如果为null，则返回null
public E pollLast()
//检索获取第一个元素，并移除它
如果为null则抛出NoSuchElementException
public E pop()

其他

public ListIterator<E> listIterator(int index)
//
public Iterator<E> descendingIterator()
//注意与Iterator的区别
private class ListItr implements **ListIterator**<E>{
    public E next() {
        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
    public void add(E e)
    public void set(E e)
    public boolean hasPrevious()
    public E previous()

}