LinkedList

1、同ArrayList一样，非同步实现，在创建时就要完成“包装”，

　　　　格式：List<> list = Collections.synchronizedList(new LinkedList(....));

2、节点之间通过指针连接，记录下一节点的地址：

　　　　头结点：

/**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

 

　　　　尾节点：

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

3、LinkedList继承体系：

 

 

 　　　　1）继承了Deque：boid-addFirst();，void-addLast();

　　　　 2）继承了List：boolean-add();，void-add(int index,E element);

public void add(int index, E element) {
        checkPositionIndex(index);//先校验index的合法性

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

private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

4、核心搜索方法：

　　　　

/**
* Returns the (non-null) Node at the specified element index.
返回指定元素索引处的（非空）节点
 */
Node<E> node(int index) {
    // assert isElementIndex(index);

if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)//若索引小于size/2，从首部向后查找
            x = x.next;
        return x;
} else {　　　　　　　　　　　　//若索引大于size/2,从尾部向前查找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
}
}

 

 

 

 

 

/**
* Inserts element e before non-null Node succ.
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
pred.next = newNode;
size++;
modCount++;
｝

5、remove：

　　boolean-remove(Object obj):

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

　　Integer-remove(int Integer):

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

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;//返回删除的节点，做个纪念，6666
}

 

 

/**
 * Pointer to last node.
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
transient Node<E> last;