LinkedList、ArrayList源码阅读笔记&总结

LinkedList、ArrayList源码阅读笔记&总结

总结：

1.随机访问：使用ArrayList更快，ArrayList直接根据数组下标获取，LinkedList则要进行遍历
2.遍历：ArrayList实现了RandomAccess接口，ArrayList使用for(int i = 0; i < size; i++) 来遍历更快，LinkedList使用Iterator迭代器来遍历更快
3.插入：对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的，ArrayList效率低于LinkedList，ArrayList可能涉及数组的扩容复制，LinkedList开销的固定的，只是增加一个节点，改变两个指针指向。在列表中间插入ArrayList则涉及插入点后面的数组的整体向后移动，效率较低。
4.删除：在列表中间删除ArrayList则涉及插入点后面的数组的整体向前移动，效率较低。 LinkedList开销的固定的，只是删除一个节点，改变两个指针指向

考虑会频繁触发扩容的使用LinkedList，会深度遍历的使用ArrayList

（一）ArrayList

一、类关系：

ArrayList extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

二、内部结构：

Object[] 存数据，默认数组初始容量：10

private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;

三：构造函数：

三种构造函数：

1.Collection collection=new ArrayList();
ArrayList arrayList1=new ArrayList<>(collection);
2.ArrayList arrayList2=new ArrayList();//空数组,list 的size=0
3.ArrayList arrayList3=new ArrayList(6);//长度为为6的数组,list 的size=0

四、常用方法解析：

1. trimToSize

最小化ArrayList 实例的存储，实例的容量修改为列表的当前大小

2.isEmpty

public boolean isEmpty() {
    return size == 0;
}

3.contains

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

4.indexOf

public int indexOf(Object o) {//循环比较
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

lastIndexOf //循环比较-倒序

5.toArray

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

//直接调用Arrays.copyOf(elementData, size)，将list中的元素对象的引用装在一个新的生成数组中

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

//如果a.length小于list元素个数就直接调用Arrays的copyOf()方法进行拷贝并且返回新数组对象，新数组中也是装的list元素对象的引用，否则先调用System.arraycopy()将list元素对象的引用装在a数组中，如果a数组还有剩余的空间，则在a[size]放置一个null，size就是list中元素的个数，这个null值可以使得toArray(T[]
a)方法调用者可以判断null后面已经没有list元素了。

6.get

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

//先校验下标，返回数组[index]

7.set

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

//先校验下标，获取旧值，设置新值，返回旧值

8.add

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

//空数组第一次add:结构修改次数modCount+1,复制一个新的数组length=10
list的size+1，数组赋值; 后续需要扩容的add：结构修改次数modCount+1，复制一个新的数组length=length*1.5，list的size+1，数组赋值

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

//先校验下标,需要扩容（复制一个新的数组length=length*1.5），将index后面的元素往后移一个位置，对应位置赋值，list的size+1

9.remove

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

//先校验下标，计算需要向左移动的元素个数，index后面的元素往左移一个位置，list的size-1，数组最后一个置为null

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

//遍历找到index，然后跟remove(index)相似

10.clear

public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

//数组每一个置为null

11.addAll

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

//转数组，扩容，复制新数组，数组内容追加，size设置

（二）LinkedList

一、类关系：

 LinkedList<E> extends AbstractSequentialList<E>
   implements List<E>, Deque<E>, Cloneable, java.io.Serializable

二、内部结构：

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;
    }
}
transient Node<E> first;//指向第一个节点的指针
transient Node<E> last;//指向最后一个节点的指针

三：构造函数：

两种构造函数：

public LinkedList() {
}

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

四、常用方法解析：

1.add

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

linkLast：e设置为最后一个元素：last指向新节点e，原本last为空则把first 也指向新节点e，原本last
不为空，则把原本last 的下一个节点指向新节点e；

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

2.remove

public E remove(int index) {//校验，遍历获得对应节点,调用unlink进行删除
    checkElementIndex(index);
    return unlink(node(index));
}

public boolean remove(Object o) {//遍历后调用unlink进行删除
    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;
}

unlink删除非空节点x: （1）x是头节点，把firs指向x的下一个节点 （2）x是末节点，把last指向x的上一个节点
（3）把x的上一个节点的下一个节点指向x的下一个节点，x的上一个节点指向null，把x的下一个节点的上一个节点指向x的上一个节点，x的下一个节点指向null

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

3.indexOf：

逐个节点遍历，返回o在linkedList中的下标，不存在返回-1。

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

4.getFirst：

返回first的item

public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}
5.getLast：返回last的item
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

6.addAll：

（1）从末尾开始插入：把last赋给pred，遍历需要add的集合c,构建新节点，把pred的下一个节点指向新节点，把新节点赋给pred，遍历结束后再把pred赋给last
（2）从中间index位置开始插入：把指定位置的节点赋给succ，succ的上一节点指向pred，遍历需要add的集合c,构建新节点，把pred的下一个节点指向新节点，把新节点赋给pred，遍历结束后再把pred的下一个节点指向succ，把succ的上一节点指向pred

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;

    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }

    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        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;
}

7.get：

先校验index，遍历获得节点x的item

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

node：根据index从前或者从后遍历，返回节点x

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

8.set:

先校验index,遍历获得index对应的节点x，设置x的item=element

.public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

9.add(int index, E element)

针对从中间插入：

public void add(int index, E element) {
    checkPositionIndex(index);

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

linkBefore：在非空节点succ之前插入e：把
succ的上一个节点指向e,原本succ的上一个节点为空，则把first指向e,原本succ的上一个节点不为空，则把原本succ的上一个节点的下一个节点指向e

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

10.push(E e)

将元素插入此列表的前面:

public void push(E e) {
    addFirst(e);
}
public void addFirst(E e) {
    linkFirst(e);
}

linkFirst：first指向新节点e，原本first为空则把last也指向新节点e，原本first不为空，则把原本first的上一个节点指向新节点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++;
}

11.pop()

删除并返回此列表的第一个元素

.public E pop() {
    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; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}