上一篇文章我们着重从源码角度介绍了LinkedList给我们提供的api方法的内部实现，这一篇我们就总结一下给我们提供的api,一些方法已经在这一篇讲过，但是还会在本篇会讲解到。

第一个api方法：addFirst(E e)，将元素插入到首节点，源码如下：

 public void addFirst(E e) {
        linkFirst(e);
    }

通过上一篇对linkFirst的源码学习，addFirst是不是非常的好理解，就是把元素添加到首节点。

第二个api方法：addLast(e e),将元素插入到末尾，源码如下：

public void addLast(E e) {
        linkLast(e);
    }

通过上一篇对linkLast的源码学习，addLast方法也是非常的容易理解

第三个api方法：add(e),添加元素

public boolean add(E e) {
        linkLast(e);
        return true;
    }

我们可以看到往LinkedList添加元素，默认也是添加到末尾，直接滴啊用的linkLast方法

第四个api方法：add(int index,E e) 插入元素

public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

这个方法首先判断index的合法性，必须满足0<=index<=size，如果不满足，则会抛异常，如果index==size,则直接调用linkLast方法，如果0<=index<size,则直接调用indexBefore方法

第五个api方法：offer(E e)

public boolean offer(E e) {
        return add(e);
    }

因为LinkedList实现了Deque接口，offer直接调用的add(E e)方法插入到链表的尾部

第六个api方法：offerFirst(E e)

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

直接调用addFirst方法

第七个api方法：offerLast(E e)

public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

第八个api方法：push(E e)

public void push(E e) {
        addFirst(e);
    }

第九个api方法：removeFirst()，移除第一个节点

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

如果链表是空链表，移除节点则会抛出异常，然后直接调用我们上一篇讲解的unlinkFirst方法

第十个api方法：removeLast(),移除最后一个节点

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

第十一个api方法：remove(Object e)

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

这个方法也是非常的简单，判断移除的节点是否为null,然后调用unlink方法进行移除

第十二个api方法：remove(int index)

 public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

第十三个api方法：peek(),获取第一个元素，但是不移除

 public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

第十四个api方法：poll(),获取第一个元素，并将其从链表中移除

public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

第十五个api方法：remove()，默认删除第一个元素

public E remove() {
        return removeFirst();
    }

第十六个api方：peekFirst(),获取第一个元素，但不移除

public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

第十七个api方法：peekLast(),获取最后一个元素，但是不移除

 public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

第十八个api方法：pollFirst(),获取第一个元素，并且从链表移除

public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

第十九个api方法：pollLast()，获取最后一个元素，并且从链表移除

public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

第二十个api方法：pop(),弹出第一个元素

 public E pop() {
        return removeFirst();
    }

除了上面的方法外还有set(index,e),addAll,clear等方法，这里不再介绍，从这些api中我们可以总结出，添加或者插入的方法最终会调用linkFirst/linkBefore/linkLast三个内部的方法，删除的方法会最终调用unlinkFirst/unlinkLast/unlink三个内部的方法，而这些内部的方法无非就是对底层链表的增加或者删除。