集合源码分析之--LinkedList

GLinkedList底层时基于链表结构

LinkedList内部结构及属性

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable {
    transient int size;//元素个数
    transient LinkedList.Node<E> first;//第一个
    transient LinkedList.Node<E> last;//最后一个
    private static final long serialVersionUID = 876323262645176354L;

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

构造函数解析

链表里面只有一个first和last，其他的元素通过Node对象的next和prev进行出串联

public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
}
//添加集合到LinkedList中
public boolean addAll(int index, Collection<? extends E> c) {
        //检查要插入的位置index >= 0 && index <= size（必须大于0，小于=最后一个元素位置）
        //否则你要插入的位置放哪里？？？
        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;//当前位置last作为上一个位置存在
        } else {
            //根据index找到链表index要插入位置的头
            succ = node(index);//node方法实现
            //找到下一个元素
            pred = succ.prev;
        }
        //循环要插入的集合
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //初始化链表元素Node--上一个元素，下一个元素没得
            Node<E> newNode = new Node<>(pred, e, null);
            //如果上一个节点没得
            if (pred == null)
                first = newNode;//设置为第一个节点
            else
                pred.next = newNode;//否则将当前元素设置到
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
}

//node方法实现
Node<E> node(int index) {
        // assert isElementIndex(index);
        //二分法查找，先判断index在size/2的前半段还是后半段
        if (index < (size >> 1)) {//前半段
            Node<E> x = first;//设置头节点
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;//找到头节点的next返回
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;//找到上一页节点
            return x;//找到尾节点的
        }
}

//根据位置获取链表元素位置
public E get(int index) {
   checkElementIndex(index);
   return node(index).item;//所以这个item就是第三个元素位置的数据（index从0开始算--数组思想）
}

//通过二分法查找index所在链表的位置
//头部查询从first开始
//尾部查询从last开始
default Node<E> node(int index) {
        // assert isElementIndex(index);
        //判断index在链表的前半段还是后半段
        if (index < (size >> 1)) {
            //前半段--正向循环
            Node<E> x = first;//从链表第一个元素开始
            for (int i = 0; i < index; i++)
                x = x.next;//加入链表size为3，index=2时，表示要取0,1,2第三个位置的元素
                //for循环0时取first.next(第二个元素Node)first.next.next 1时取第三个元素Node
                //这个时候要取第三位置元素，所以直接取
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
}

SET

//往index位置，Replaces替换元素
public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
}
1、首先从链表的角度来讲，链表插入是很快的，只需要移动链表Node里面的prev和next位置即可，但是数组就不一样还得需要system.copy底层拷贝，将数组元素进行移动才得行
--替换思路
1、检查要替换的index是否在链表size范围内（index>=0 && index<size）
2、根据index找到要插入链表index位置的Node，然后取出来
3、直接将index位置的Node的item改成要替换的element即可

ADD

//在index位置插入新元素
public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
}
//插入思路
1、首先要检查要插入的位置是否在0-size之间（含0和size）如果等于size意思就是在链表最后追加一个元素
情况1，加入index==size时，加入链表最后
（1）首先判断链表last是否==null
--是，直接将first=last=element,然后将size=1;modCount++
linkLast
--源代码：找到last,new一个Node将prev设置为last。新加入元素的上一个节点为last
--加入last为空，则当前这个节点设置为first。否则将last.next = new新的节点
linkBefore
--否，找打index所在链表的Node元素
----通过二分法查找node，node方法之前已经详细分析过了
----然后将element放到index位置，如何放？
原来index的Node位置=node(index)
Node oldNode = node(index);
oldNode.prev = element;将旧的Node的上一个元素设置为element
然后将element.next = oldNode;将elment的下一个元素设置为oldNode（这些动作在new Node的时候已经完成）
--源代码：
找打要插入节点的原节点的上一个元素（记录起来）
然后new新节点，将新节点的上一个节点设置为原节点的上一个节点；（那么原节点的上一个节点，就要设置为新节点succ.prev = newNode）
====下面看看源码
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;
    //然后还要看看，原节点的上一个节点是不是null的，如果是意思就是在头部插入的；要将新节点设置为first；否则原节点的一下个节点要设置为新节点
    if (pred == null)
       first = newNode;
    else
       pred.next = newNode;
    size++;
    modCount++;
}
//上面linkBefore做了那么多事情，关键思路就是
1、需要把新的插入节点给new出来，然后把上一个节点的next分情况，设置为新插入的节点node
2、原节点的prev节点的next要设置为newNode，如果原节点prev为null时，那么说明插入位置就是fisrt
3、然后调整原节点原节点的prev要设置为新节点

//index=size
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
       first = newNode;
    else
       l.next = newNode;
    size++;
    modCount++;
}

remove

//删除链表中的index位置的节点
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
}

checkElementIndex
检查index在0-size之间（含0）,可以理解为数组元素位置
unlink实现思考
自己理解
Node oldNode = node(index);//要删除的节点
进行链表操作
Node oldNodePrev = oldNode.prev;//要删除的链表的上一个节点
Node oldNodeNext = oldNode.next;//要删除的链表的下一个节点
如果oldNodePrev==null表示移除的链表第一个节点first
fisrt = oldNodeNext;//将要删除的链表的下一个节点设置为fisrt(思路一致）
如果oldNodePrev!=null
oldNodePrev.next = oldNodeNext;//思路一致
--将原删除链表的上一个节点设置为oldNodePrev 
oldNodeNext.prev = oldNodePrev;
如果oldNodeNext ==null那么
last= oldNodePrev ;
如果oldNodeNext !=null那么

===源代码怎么说
E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;//要删除的item
        final Node<E> next = x.next;//oldNodeNext
        final Node<E> prev = x.prev;//oldNodePrev

        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;//GC work
        size--;
        modCount++;
        return element;
}

一些基本操作

//获取一个元素
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);
}

//unlinkFirst思路思考
1、将first的next取出来
2、将next作为first
private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;//待移除的节点
        final Node<E> next = f.next;//找到原first的next节点
        f.item = null;//将原删除节点设置为null
        f.next = null; // help GC
        first = next;//将next设置为first
        if (next == null)
            last = null;
        else
            next.prev = null;//first的prev必然为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) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
}

小结：
1、链表底层就是对Node-prev和next进行设置
2、每次操作基于size然后取Nodex
3、根据first和last判断要正向遍历处理还是逆向

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作为加入节点的next
   first = newNode;
   if (f == null)//如果原来的first为null，则当前节点就是first
      last = newNode;
   else
      f.prev = newNode;//否则将原来的fisrt的上一个节点设置为新增节点
   size++;
   modCount++;
}
//
public void addLast(E e) {
   linkLast(e);
}
//
void linkLast(E e) {
        final Node<E> l = last;//先把last节点找到
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
}

//查询参数节点在链表的位置（0开始计算）
public int indexOf(Object o) {
        int index = 0;//初始化设置为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;
}
//lastIndexOf由链表逆向遍历，取prev
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;
}
//peek没有就返回Null
public E peek() {
  final Node<E> f = first;
  return (f == null) ? null : f.item;
}
//如果为空时，要抛异常
public E element() {
   return getFirst();
}
//检索，并删除链表的第一个元素（这个有点类似于队列取元素）--从头部开始取
public E poll() {
   final Node<E> f = first;
   return (f == null) ? null : unlinkFirst(f);
}
//删除第一个节点，如果为空，抛异常的
public E remove() {
  return removeFirst();
}
//Deque接口--Queue队列接口（为了让linkedList具有Deque的功能）
//指定的元素添加为LinkedList的最后一个元素
public boolean offer(E e) {
   return add(e);
}
//取出一个节点并删除
public E pop() {
    return removeFirst();
}
//
public <T> T[] toArray(T[] a) {
        if (a.length < 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;
}

List总结：

可以重复，通过索引取出加入数据，顺序与插入顺序一致，可以含有null元素

ArrayList:底层数据结构使数组结构array，查询速度快，增删改慢，因为是一种类似数组的形式进行存储，因此它的随机访问速度极快；

Vector：底层是数组结构array，与ArrayList相同，查询速度快，增删改慢；

LinkedList:底层使用链表结构，增删速度快，查询稍慢；

ArrayList与Vector的区别：

1.如果集合中的元素数量大于当前集合数组的长度时，Vector的增长率是目前数组长度的100%，而ArryaList增长率为目前数组长度的50%。所以，如果集合中使用数据量比较大的数据，用Vector有一定优势

2.线程同步ArrayList是线程不同步，所以Vector线程安全，但是因为每个方法都加上了synchronized，所以在效率上小于ArrayList