java集合框架-----List源码学习(LinkedList)

LinkedList: 基于双向链表的实现,线程不安全,增删快查找慢,线程不安全,可以当队列使用
参考: https://www.cnblogs.com/skywang12345/p/3308807.html
https://zhuanlan.zhihu.com/p/158755866
https://zhuanlan.zhihu.com/p/210732993

LinkedList属性:
transient int size = 0; // 双向链表的节点个数
transient Node first; // 双向链表指向头节点的指针
transient Node last; // 双向链表指向尾节点的指针

transient关键字:参考 https://www.cnblogs.com/lanxuezaipiao/p/3369962.html
1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

Node源码:

 private static class Node<E> {
        E item;  // item表示当前存储元素
        Node<E> next; // next表示当前节点的后置节点
        Node<E> prev; // prev表示当前节点的前置节点

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

构造方法:

//无参
public LinkedList() {
}
//有参
  public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

1.在末尾添加元素

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

 void linkLast(E e) {
        final Node<E> l = last;  // 最后一个节点赋值给l
        final Node<E> newNode = new Node<>(l, e, null); //创造一个新节点 
        last = newNode; // 将新节点赋值给最后一个节点
        if (l == null)  //链表为空，则将newNode赋值给first节点
            first = newNode;   
        else
			l.next = newNode;  // 尾节点的last指向 newNode
			size++;
			modCount++;
    }

2.在指定位置添加:

public void add(int index, E element) {
        checkPositionIndex(index); // 检查索引index的位置

        if (index == size)
            linkLast(element);   //索引是末尾,就在末尾添加相当于  add(E e)方法
        else
            linkBefore(element, node(index));
    }	
	
	
  private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
	//指定位置必须大于0 且小于列表长度
	 private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }


//获取指定索引的非空节点
    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) { //二分法查找   如果索引在前半部,则从前向后查找
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {    //否则从后向前查找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

3.将新元素添加到头部:

  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;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

4.在队尾添加:(不看了)

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

5.在指定位置添加:

  void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;  //指定节点的前一个节点
		 // 创建新的节点，前驱节点为succ的前驱节点，后续节点为succ，则e元素就是插入在succ之前的
        final Node<E> newNode = new Node<>(pred, e, succ);  
        succ.prev = newNode;  // 构建双向链表，succ的前驱节点为新的节点
        if (pred == null) 如果前驱节点为空,则第一个节点就是新节点
            first = newNode;
        else
            pred.next = newNode;  //前驱节点的后一个节点指向新的节点
        size++;
        modCount++;
    }

6.获取指定位置的节点

public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

7.删除最前面的节点:

 public E remove() {
        return removeFirst();
    }
	
  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; // 当前节点的下一个节点置空
        first = next;  //将第二位置的节点赋值给第一个节点
        if (next == null)
            last = null;  //如果第二位置的节点为空,怎将最后一个节点也置空, 相当于整个链表都是空的
        else
            next.prev = null;  //第二个节点的前置节点置空(跟之前的第一个节点断开联系)
        size--;
        modCount++;
        return element;
	}

8.删除指定位置的节点:

public E remove(int index) {
        checkElementIndex(index);  //检查索引
        return unlink(node(index));//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;
    }

9.删除第一个节点:

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

10.删除最后一个节点:(找到最后一个节点直接调用删除指定节点)

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

将指定索引的节点,重新赋值:
  public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index); //获取指定节点
        E oldVal = x.item;
        x.item = element;  //重新赋值
        return oldVal;
    }