集合框架源码学习之LinkedList

简介

• 基于双向链表实现
• 可当做栈和队列使用
• 非线程安全
• 实现Serializable接口、Cloneable接口，支持序列化和克隆

源码

构造方法

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() {
        }
        //将传进来的集合进行初始化链表
        public LinkedList(Collection<? extends E> c) {
            this();
            addAll(c);
        }
}

方法

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);
}
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;//方便垃圾回收
    f.next = null; // help GC
    first = next;//将first赋值为原来的第二个元素
    if (next == null)//如果原来的第二个元素为null，则最后一个元素也要赋值为null
        last = null;
    else
        next.prev = null;//将原第二个节点的前指针赋值为null
    size--;
    modCount++;
    return element;//将删除元素的值返回
}

public E removeLast() {//删除最后一个元素
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}
private E unlinkLast(Node<E> l) {
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;//方便垃圾回收
    l.prev = null; // help GC
    last = prev;//将last指向原本last的上一个元素
    if (prev == null)//如果只有一个元素，则first也要为null
        first = null;
    else
        prev.next = null;//将现在的最后节点的下一个节点指向null
    size--;
    modCount++;
    return element;//将操作的元素的值返回
}

public void addFirst(E e) {//添加元素到到一个
    linkFirst(e);
}
private void linkFirst(E e) {//将新元素添加都头结点
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);//新建一个元素
    first = newNode;//将first指向新的节点
    if (f == null)//如果列表原本没有元素，则将last也指向新的元素
        last = newNode;
    else
        f.prev = newNode;//此时f指向的是第二个元素，newNode赋为f的前一个元素
    size++;
    modCount++;
}

public void addLast(E e) {//添加元素到最后一个
    linkLast(e);
}
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);//创建一个元素
    last = newNode;//让last指向新的元素
    if (l == null)//如果原本集合中没有元素，则将first也指向新的元素
        first = newNode;
    else
        l.next = newNode;//此时l为倒数第二个元素，将它的下一个元素指向newNode
    size++;
    modCount++;
}

public boolean contains(Object o) {//确定是否包含此元素
    return indexOf(o) != -1;
}
public int indexOf(Object o) {
    int index = 0;
//分两种情况：第一种情况为null，第二种情况为非null
    if (o == null) {//从头遍历，只要找到一个元素的值为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;//找不到则返回-1
}

public int size() {//返回当前集合的长度
    return size;
}

public boolean add(E e) {//如果没有指定添加的位置，则默认添加到最后面
    linkLast(e);
    return true;
}

public boolean remove(Object o) {//删除指定元素
//分两种情况：值为null与非null
//从头遍历，匹配到了则将值对应的元素从列表中删除
    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;
}

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;
//将要被删除的元素与其前一个元素的双向连接摘断，前一个元素的next指向原本的next    
if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }
//将要被删除的元素与其后一个元素的双向连接摘断，并将后一个元素的prev指向原本的prev
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

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;//如果是添加在原集合的最后，则更新last
    } else {
        pred.next = succ;
        succ.prev = pred;
//两句话的意思是：将插入的所有元素中的最后一个元素与原本集合被中断的那个元素前后连接起来
    }

    size += numNew;//扩展长度
    modCount++;
    return true;
}
Node<E> node(int index) {
//先判断是在长度1/2的哪一边
    if (index < (size >> 1)) {//小于1/2长度，从第一向后
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {//大于1/2长度，从后向前
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

    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;//获取对应元素的值，node为前面的方法
}

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)//如果是size，则直接添加到最后面
        linkLast(element);
    else
        linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {//将元素插进到succ的前面
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)//如果succ是第一个元素，则直接让first指向插入的元素
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

public E remove(int index) {//删除指定位置的元素
    checkElementIndex(index);
    return unlink(node(index));//将索引到的元素从链表中删除
}

public E poll() {//弹出链表中第一个元素并删除
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

public boolean offer(E e) {//将元素添加到最后
    return add(e);
}

public E remove() {//删除第一个元素
    return removeFirst();
}

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;
}

public int lastIndexOf(Object o) {//从尾到头
    int index = size;
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}

public void push(E e) {//以栈的形式添加
    addFirst(e);
}

public E pop() {//出栈
    return removeFirst();
}

public ListIterator<E> listIterator(int index) {//获取一个指定位置的迭代器
    checkPositionIndex(index);
    return new ListItr(index);
}

public Object[] toArray() {//将当前链表里节点对应的值转换成数组
    Object[] result = new Object[size];
    int i = 0;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    return result;
}
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
//将当前链表里节点对应的值放到数组，转换后不用进行类型转换
    if (a.length < size)//如果数组的长度小于链表的长度，则重新创建一个长度为size
        a = (T[])java.lang.reflect.Array.newInstance(
                            a.getClass().getComponentType(), size);
    int i = 0;
    Object[] result = a;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;

    if (a.length > size)
        a[size] = null;
    return a;
}

迭代器

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;
    private Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        //如果位置是链表长度，则next为null,否则找到指定位置的元素
    //把下一个索引赋值给nextIndex
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }

    public boolean hasNext() {//判断还有没有下一个元素
        return nextIndex < size;
    }

    public E next() {//获取下一个元素
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();
        lastReturned = next;
        next = next.next;//重新赋值给next：让next指向下一个
        nextIndex++;//当前索引加1
        return lastReturned.item;//返回当前元素对应的值
    }

    public boolean hasPrevious() {//判断是否有前一个元素
        return nextIndex > 0;
    }
    public E previous() {//获取当前位置的前一个元素
        checkForComodification();
        if (!hasPrevious())
            throw new NoSuchElementException();
//如果next已经是last.next，则返回last，否则正常返回next.prev
        lastReturned = next = (next == null) ? last : next.prev;
        nextIndex--;
        return lastReturned.item;
    }

    public int nextIndex() {//获取当前索引
        return nextIndex;
    }

    public int previousIndex() {//获取当前索引的上一个
        return nextIndex - 1;
    }

    public void remove() {//删除当前指向的元素
        checkForComodification();
        if (lastReturned == null)
            throw new IllegalStateException();

        Node<E> lastNext = lastReturned.next;
        unlink(lastReturned);//删除最后一次返回的元素
        if (next == lastReturned)
            next = lastNext;//将next指向最后返回元素的下一个
        else
            nextIndex--;
        lastReturned = null;//防止连续的删除
        expectedModCount++;
    }

    public void set(E e) {//给当前元素更新对应的值
        if (lastReturned == null)
            throw new IllegalStateException();
        checkForComodification();
        lastReturned.item = e;
    }

    public void add(E e) {//添加元素
        checkForComodification();
        lastReturned = null;
        if (next == null)//如果next已经超过链表中的元素，则添加新元素到最后
            linkLast(e);
        else            //否则将新元素添加到next的前面
            linkBefore(e, next);
        nextIndex++;
        expectedModCount++;
    }

Node的结构

//实际是一个双向链表
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;
    }
}

总结

• 基于双向链表，保持有头指针跟尾指针，但头尾不相连
• 两个构造方法：默认构造方法、传进来集合的构造方法
• 允许元素为null，在查找元素的时候分null和非null查找
• 遍历链表的时候，有一个加速操作：if (index < (size >> 1))//折半，这样可以节省一半的时间
• 对增删的操作效率高，无需移动节点
• 队列操作:

public E peek()//获取第一个元素的值，如果没有元素则返回null
public E element()//获取第一个元素的值，如果没有元素则抛异常
public E poll()//删除队头
public E remove()//删除队头，如果队头为null之抛出异常
public boolean offer(E e) //添加元素到队后面

• 栈操作：

public void push(E e) //添加
public E pop()//删除栈顶