Android LinkedList★★

1. LinkedList

LinkedList是基于双向链表实现的。

先看看链表结构都有哪些：

①单向链表

   element：用来存放元素

    next：用来指向下一个节点元素

    通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。

 ②单向循环链表

    element、next 跟前面一样。

    在单向链表的最后一个节点的next会指向头节点，而不是指向null，这样存成一个环。

 ③双向链表 

   element：存放元素

    pre：用来指向前一个元素

    next：指向后一个元素

双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。

 ④双向循环链表

    element、pre、next 跟前面的一样。

第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，形成一个环。

 

LinkedList的数据结构是第三种—双向链表。

 如上图所示，LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作。 

LinkedList的特性：

①是通过链表实现的；

②查询效率不高，但是插入和删除操作性能好。如果在频繁的插入或者删除数据时，就用linkedList性能会更好。

③linkedList是一个双向链表，并且实现了List和Deque接口中所有的列表操作，并且能存储任何元素，包括null。也就是说linkedList除了可以当链表使用，还可以当作队列使用，并能进行相应的操作。

④linkedList在执行任何操作的时候，都必须先遍历列表，通过index查找我们所需要的的值。通俗点讲，就是顺序存取，每次操作必须先按开始到结束的顺序遍历。

⑤linkedList是一个非线程安全的(异步)，其中在操作Interator时，如果改变列表结构(add\delete等)，会发生fail-fast。

 

2.LinkedList的属性

LinkedList的属性有3个：一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。

    transient int size = 0;// 实际元素个数

    transient Node<E> first;// 头结点

    transient Node<E> last; // 尾结点

注意，头结点、尾结点都有transient关键字修饰，这也意味着在序列化时该域是不会序列化的。

LinkedList有一个内部类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;

    }

}

内部类Node就是实际的结点，用于存放实际元素的地方。

 

3.构造方法

LinkedList有两个构造方法。

①空参构造函数

 public LinkedList() {

 }

②有参构造函数

//将集合c中的各个元素构建成LinkedList链表

public LinkedList(Collection<? extends E> c) {

        this(); // 调用无参构造函数

        addAll(c); // 添加集合中所有的元素

}

有参构造函数会调用无参构造函数，并且会把集合中所有的元素添加到LinkedList中。

 

4.添加方法

①add(E) 新增元素到尾部

public boolean add(E e) {

     linkLast(e);//将元素添加到末尾

     return true;

}

void linkLast(E e) {

     final Node<E> l = last;   //临时节点l(L的小写)保存last，也就是l指向了最后一个节点

     final Node<E> newNode = new Node<>(l, e, null);   //将e封装为节点，并且e.prev指向了最后一个节点

     last = newNode;   //newNode成为了最后一个节点，所以last指向了它

     if (l == null)  //判断是不是一开始链表中就什么都没有，如果没有，则newNode就成为了第一个节点，first和last都要指向它

          first = newNode;

     else //正常的在最后一个节点后追加，那么原先的最后一个节点的next就要指向现在真正的最后一个节点，原先的最后一个节点就变成了倒数第二个节点

          l.next = newNode;

     size++;//添加一个节点，size自增

     modCount++;

}

②addAll方法

addAll有两个重载函数。

1)、addAll(Collection<? extends E> c)方法

public boolean addAll(Collection<? extends E> c){

    return addAll(size, c);

}

2)、addAll(int index, Collection<? extends E> c)方法

public boolean addAll(int index, Collection<? extends E> c) {

    checkPositionIndex(index);  //检查index是否为合理，其实就是检查角标是否小于0或者是否越界

    Object[] a = c.toArray();  //将集合c转换为Object数组 a

    int numNew = a.length;  //获取数组a的长度

    if (numNew == 0)

        return false;

    Node<E> pred, succ; //如果集合c是非空的，定义两个节点，用来做临时存储节点，succ是当前要插入位置的节点，pred是要插入位置的前一个位置节点

    if (index == size) {//在结尾追加元素

        succ = null;

        pred = last;

    } else {

       //如果在链表中间插入元素，那么就得知道index上的节点是谁，保存到succ临时节点中，然后将succ的前一个节点保存到pred中，这样保存了这两个节点，就能够准确的插入节点了

        succ = node(index);

        pred = succ.prev;

    }

    for (Object o : a) { //遍历数组a中的元素，封装为一个个节点

        Node<E> newNode = new Node<>(pred, e, null); //构建一个Node节点，pre为pred，e为当前元素，next为null

        if (pred == null)

            first = newNode; //如果pred为空,说明是一个空链表,此时的newNode就当作第一个节点，所以把newNode给first头节点

        else

            pred.next = newNode; //如果pred != null，说明需要将newNode挂在pred的next上

        pred = newNode;

    }

    if (succ == null) {

        last = pred;

    } else {

        pred.next = succ;//当a里的元素循环加入完以后，将最后加入的那个元素的next指向add方法前位于index位置的那个元素

        succ.prev = pred;

    }

    size += numNew;

    modCount++;

    return true;

}

参数中的index表示在索引下标为index的结点的前面插入。在addAll函数中，会调用到node函数，get函数也会调用node函数，此函数是根据索引下标找到该结点并返回，具体代码如下：

Node<E> node(int index) {

    // 判断插入的位置在链表前半段还是后半段

    if (index < (size >> 1)) { // 插入位置在前半段

        Node<E> x = first; 

        for (int i = 0; i < index; i++) // 从头结点开始正向遍历

            x = x.next;

        return x; // 返回index处的结点

    } else { // 插入位置在后半段

        Node<E> x = last; 

        for (int i = size - 1; i > index; i--) // 从尾结点开始反向遍历

            x = x.prev;

        return x; // 返回index处的结点

    }

}

addAll()中有一个疑问：在addAll函数中，传入一个集合参数和插入位置，然后将集合转化为数组，再遍历数组，挨个添加数组的元素，但是问题来了，为什么要先转化为数组再进行遍历，而不是直接遍历集合呢？从效果上两者是完全等价的，都可以达到遍历的效果。关于为什么要转化为数组的问题，思考如下：

①如果直接遍历集合的话，那么在遍历过程中需要插入元素，在堆上分配内存空间，修改指针域，这个过程中就会一直占用着这个集合，考虑正确同步的话，其他线程只能一直等待。

②如果转化为数组，只需要遍历集合，而遍历集合过程中不需要额外的操作，所以占用的时间相对是较短的，这样就利于其他线程尽快的使用这个集合。说白了，就是有利于提高多线程访问该集合的效率，尽可能短时间的阻塞。

 

5.删除方法

public boolean remove(Object o) {

     if (o == null) {

         for (Node<E> x = first; x != null; x = x.next) {//循环遍历链表，直到找到null值，然后使用unlink移除该值

               if (x.item == null) {

                    unlink(x);//使用unlink移除该值

                    return true;

               }

          }

     } else {

          for (Node<E> x = first; x != null; x = x.next) {

               if (o.equals(x.item)) {

                    unlink(x);//使用unlink移除该值

                    return true;

               }

          }

     }

     return false;

}

其中用到了unlink方法：

E unlink(Node<E> x) {

     //拿到节点x的三个属性

     final E element = x.item;

     final Node<E> next = x.next;

     final Node<E> prev = x.prev;

     //这里开始往下就进行移除该元素之后的操作，也就是把指向哪个节点搞定

     if (prev == null) {

          first = next;//说明移除的节点是头节点，则first头节点应该指向下一个节点

     } else {

          prev.next = next; //移除的不是头节点

          x.prev = null;//然后解除x节点的前指向

     }

    if (next == null) {

          last = prev;//说明移除的节点是尾节点

     } else {

          //不是尾节点，有1、2、3，将3.prev指向1. 然后将2.next=解除指向

          next.prev = prev;

          x.next = null;

     }

     //x的前后指向都为null了，也把item为null，让gc回收它

     x.item = null;

     size--; //移除一个节点，size自减

     modCount++;

     return element;

}

 

6.查询方法

①get(index)方法：

public E get(int index) {

    checkElementIndex(index);

    return node(index).item;

}

Node<E> node(int 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;

    }

}

②indexOf(Object o)方法

通过实体元素查找到该元素在链表中的位置

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;

}

 

7.总结

①linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。

②能存储null值

③跟arrayList相比较，LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好

④从源码中看，它不存在容量不足的情况

⑤linkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。

⑥linkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。