基于jdk12 阅读集合源码之：ArrayList和LinkList

ArrayList的源码分析

为此要通过源码了解以下特点：1.用动态数组实现 2.线程不安全 3.查找快，增删慢
首先是三个构造方法：

public ArrayList(int initialCapacity) {
    //如果大于0 就直接初始一个该长度的数组对象 并赋值回去
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //等于0 的话就空数组对象empty_elementdata 复制 private static final Object[] EMPTY_ELEMENTDATA = {};
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        //否则就抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    }
}

和

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    //先把c集合转换为数组
    Object[] a = c.toArray();
    //在判断数组是不是等于0
    if ((size = a.length) != 0) {
        //如果类型应用 就直接赋值
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            //不然就进行数组的拷贝
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        //如果等于0 就引用一个空数组
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

然后是ArrayList 新增对象

这里要注意的是 jdk12 的add方法进行了修改！！！

public boolean add(E e) {
    //直接记录ArrayList的变化次数
    modCount++;
    //调用私有的add方法
    add(e, elementData, size);
    return true;
}

私有的方法

private void add(E e, Object[] elementData, int s) {
    //r如果长度够的话 就进行扩容
    if (s == elementData.length)
        elementData = grow();
    //没有满的话 就直接赋值 再把size增加
    elementData[s] = e;
    size = s + 1;
}

关于grow 这里有个知识点

将oldCapacity 右移一位，其效果相当于oldCapacity
/2，//我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //这里就设置了新的Capacity是原来的1.5倍
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, /* minimum growth */
                oldCapacity >> 1           /* preferred growth */);

        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

双参数的add

//双参数的
public void add(int index, E element) {
    //先检查add位置是否合理
    rangeCheckForAdd(index);
    //ArrayList 增加次数加一
    modCount++;
    final int s;
    Object[] elementData;
    //size等于缓冲区的长度 直接扩容
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    //调用系统的数组copy方法，比如123456 index=3 执行一下就是 1234456 再把对应换成element 也就是系统的增大方式吧
    System.arraycopy(elementData, index,
            elementData, index + 1,
            s - index);
    elementData[index] = element;
    size = s + 1;
}

再是ArrayList的移除元素

public E remove(int index) {
    //先判断有没有越位
    Objects.checkIndex(index, size);
    final Object[] es = elementData;
    //这个备注就是 如果前面没有出错的话 就将原本要删除的值 赋予oldValue 作为返回值
    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    //再调用 快速删除的方法来进行删除
    fastRemove(es, index);

    return oldValue;
}

fastRemove

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    //因为值删除一个数  所以newSize作为删除完了之后的大小 是需要判断并且大于i的，不然会报出异常
    if ((newSize = size - 1) > i)
        //这里就是调用了 系统的复制方法 假设就是从es[i+1] 这个地方开始拷贝 覆盖掉es[i]这个位置 从后往前开始拷贝的
        //假设 是123456 i等于2 就会执行变成  124566
        System.arraycopy(es, i + 1, es, i, newSize - i);
    //并且将最后一位设置为null
    es[size = newSize] = null;
}

从这里可以发现一个细节：
在元素移除的时候，并没有缩小数组的长度（size 不是数组的length ,只是一个长度的标识） ，而仅仅是将后面的数组向前排列，然后将最后一个数组设置为Null

还有一种重载的remove方法：

public boolean remove(Object o) {
    final Object[] es = elementData;
    final int size = this.size;
    int i = 0;
    found: {
        //如果元素等于null 就找到数组中为Null 的值 进行删除
        if (o == null) {
            for (; i < size; i++)
                if (es[i] == null)
                    break found;
        } else {
            //如果不为null 就equals到对应的值 然后还是用fastRemove 进行删除
            for (; i < size; i++)
                if (o.equals(es[i]))
                    break found;
        }
        return false;
    }
    fastRemove(es, i);
    return true;
}

从这里也可以发现一个细节： 只要发现当前元素等于目标元素的话 就立刻停止删除，删除之后也并不会继续遍历完，所以每次都只会删除一个元素， 就像
123null4null5 调用方法之后 就变成 1234null5
而且这里把null 和不是null分开写
主要是因为，后面要调用0.equals() 方法进行判断 如果是null的话 就会出现空指针异常了。

然后是LinkList

对于这个来说，重点就是双向链表的实现，支持null和重复值。好像和ArrayList一样，没有强调是不是重复的值，并且由于链表的存在，不需要扩容。
关于构造函数

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

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
    //检查是否有序
    checkPositionIndex(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    //初始化 一个是尾部 一个是头部
    LinkedList.Node<E> pred, succ;
    if (index == size) {
        //如果需要插入的就是在尾部的话 就把尾部设置为null，头部设置为最后一个位置
        succ = null;
        pred = last;
    } else {
        //不然的话 就是在中间插入尾部指向对应要插入的位置 头部就指向尾部的前面一个
        succ = node(index);
        pred = succ.prev;
    }

    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        //先构造一个新的结点
        LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, null);
        //如果前置结点是null的话  说明没有前置结点 就可以理解为在链表的头部插入那就需要设置新的结点为前置结点
        if (pred == null)
            first = newNode;
        else
            //不然的话 就把新的结点插入到前置结点的后一个
            pred.next = newNode;

        pred = newNode;
    }

    if (succ == null) {
        //如果后置节点是null 的话 也就是说明是从尾部插入的 那就将原本的前置结点设置为原来链表的最后一个节点
        last = pred;
    } else {
        //不然的话 就通过另一个方法插入
        pred.next = succ;
        succ.prev = pred;
    }

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

然后是add方法：

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

再看一下 LinkLast

void linkLast(E e) {
    final LinkedList.Node<E> l = last;
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
    last = newNode;
    //这个的意思 应该算是默认从尾部插入
    // 如果这个尾部的结点是null 也就是空的话， 也就是last是空
    if (l == null)
        //那就说明链表是空的 将新的结点设置为null即可
        first = newNode;
    else
        //不然的话 就把新的结点插入到最后一个位置当中
        l.next = newNode;
    size++;
    modCount++;
}

所以是默认会把元素添加到尾部的

然后是把元素添加到指定位置

public void add(int index, E element) {
    //先检查有没有越界
    checkPositionIndex(index);
    //如果刚好在尾部的话 就直接按照原来的 从尾部插入
    if (index == size)
        linkLast(element);
    else
        //不然就是调用这个方法 进行正常的插入
        linkBefore(element, node(index));
}

LinkBefore方法

void linkBefore(E e, LinkedList.Node<E> succ) {
    // assert succ != null;
    //前提是当前结点不为空
    final LinkedList.Node<E> pred = succ.prev;
    //初始化一个新结点 前驱是pred 后继是succ
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
    //然后把succ的前驱指向新结点
    succ.prev = newNode;
    //如果前驱是空的话 说明当前元素是第一个元素 或者当前链表为空
    if (pred == null)
        first = newNode;
    else
        //否则 pred的后继就变成了 之前succ的前驱
        pred.next = newNode;
    //新增了一个 就需要操作数和大小都加一
    size++;
    modCount++;
}

大概的思路就是：
1.创建新的结点 并指明新结点的前驱和后继
2.将succ的前驱引用指向新结点
3.如果succ的前驱不为空的话 就把succ的前驱（之前的前驱）的后继指向新结点

然后是LinkList的移除方法

public boolean remove(Object o) {
    //如果要删除的就是null的话（这里有个前提就是 linkedlist就是可以存在null的）
    if (o == null) {
        //然后从第一个开始遍历
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                //unlink就是直接删去的意思吧
                unlink(x);
                return true;
            }
        }
    } else {
        //不然的话 就一个个遍历 这边把两个都分开也是因为 下面是需要equals 直接用null会报错
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

还有按索引的

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

所有就需要再看一下 unlink

E unlink(LinkedList.Node<E> x) {
    // assert x != null;
    //先进行初始化
    final E element = x.item;
    final LinkedList.Node<E> next = x.next;
    final LinkedList.Node<E> prev = x.prev;
    //如果前是null的话 有可能就是头 表示x是第一个元素 直接让first 指向x的后继 相当于就是删掉了
    if (prev == null) {
        first = next;
    } else {
        //也就是不是在第一个的话 前驱指向x的后继 再让x 的前驱直接断了
        prev.next = next;
        x.prev = null;
    }
    //上面是双向链表的前驱部分

    //再判断后继 如果是null 的话 就说明就是最后一个
    if (next == null) {
        //直接把last指向后继
        last = prev;
    } else {
        //不然的话 就进行 后继的删除 后继的前驱等于原来的前驱 后继直接指向null
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

这些就都是 关于数据结构中链表的增加和删除的知识
参考了这个：
https://blog.csdn.net/laobanhuanghe/article/details/106162498