【集合系列】- 深刻浅出分析Collection中的List接口

时间 2019-11-16

标签集合系列深刻分析 collection list 接口栏目快乐工作繁體版

原文原文链接

1、List简介

List 的数据结构就是一个序列，存储内容时直接在内存中开辟一块连续的空间，而后将空间地址与索引对应。html

如下是List集合简易架构图java

由图中的继承关系，能够知道，ArrayList、LinkedList、Vector、Stack都是List的四个实现类。node

AbstractCollection 是一个抽象类，它惟一实现Collection接口的类。AbstractCollection主要实现了toArray()、toArray(T[] a)、remove()等方法。
AbstractList 也是一个抽象类，它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)以外的函数，好比特定迭代器ListIterator。
AbstractSequentialList 是一个抽象类，它继承于AbstractList。AbstractSequentialList 实现了“链表中，根据index索引值操做链表的所有函数”。
ArrayList 是一个动态数组，它由数组实现。随机访问效率高，随机插入、随机删除效率低。
LinkedList 是一个双向链表。它也能够被看成堆栈、队列或双端队列进行操做。LinkedList随机访问效率低，但随机插入、随机删除效率高。
Vector 也是一个动态数组，和ArrayList同样，也是由数组实现。可是ArrayList是非线程安全的，而Vector是线程安全的。
Stack 是栈，它继承于Vector。它的特性是：先进后出(FILO, First In Last Out)。

下面对各个实现类进行方法剖析！git

2、ArrayList

ArrayList实现了List接口，也是顺序容器，即元素存放的数据与放进去的顺序相同，容许放入null元素，底层经过数组实现。
除该类未实现同步外，其他跟Vector大体相同。github

在Java1.5以后，集合还提供了泛型，泛型只是编译器提供的语法糖，方便编程，对程序不会有实质的影响。由于全部的类都默认继承至Object，因此这里的数组是一个Object数组，以便可以容纳任何类型的对象。编程

经常使用方法介绍数组

2.一、get方法

get()方法一样很简单，先判断传入的下标是否越界，再获取指定元素。安全

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

/**
 * 检查传入的index是否越界
 */
private void rangeCheck(int index) {
        if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

2.二、set方法

set()方法也很是简单，直接对数组的指定位置赋值便可。markdown

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

2.三、add方法

ArrayList添加元素有两个方法，一个是add(E e)，另外一个是add(int index, E e)。
这两个方法都是向容器中添加新元素，可能会出现容量（capacity）不足，所以在添加元素以前，都须要进行剩余空间检查，若是须要则自动扩容。扩容操做最终是经过grow()方法完成的。数据结构

grow方法实现

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//原来的1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
}

添加元素还有另一个addAll()方法，addAll()方法可以一次添加多个元素，根据位置不一样也有两个方法，一个是在末尾添加的addAll(Collection<? extends E> c)方法，一个是从指定位置开始插入的addAll(int index, Collection<? extends E> c)方法。

不一样点：addAll()的时间复杂度不只跟插入元素的多少有关，也跟插入的位置相关，时间复杂度是线性增加！

2.四、remove方法

remove()方法也有两个版本，一个是remove(int index)删除指定位置的元素；另外一个是remove(Object o)，经过o.equals(elementData[index])来删除第一个知足的元素。

须要将删除点以后的元素向前移动一个位置。须要注意的是为了让GC起做用，必须显式的为最后一个位置赋null值。

remove(int index)方法

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; //赋null值，方便GC回收
        return oldValue;
}

remove(Object o)方法

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

3、LinkedList

在上篇文章中，咱们知道LinkedList同时实现了List接口和Deque接口，也就是说它既能够看做一个顺序容器，又能够看做一个队列（Queue），同时又能够看做一个栈（Stack）。

LinkedList底层经过双向链表实现，经过first和last引用分别指向链表的第一个和最后一个元素，注意这里没有所谓的哑元（某个参数若是在子程序或函数中没有用到，那就被称为哑元），当链表为空的时候first和last都指向null。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
     /**容量*/
    transient int size = 0;

    /**链表第一个元素*/
    transient Node<E> first;

     /**链表最后一个元素*/
    transient Node<E> last;
    
    ......
}

/**
 * 内部类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;
    }
}

经常使用方法介绍

3.一、get方法

get()方法一样很简单，先判断传入的下标是否越界，再获取指定元素。

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

/**
 * 检查传入的index是否越界
 */
private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

3.二、set方法

set(int index, E element)方法将指定下标处的元素修改为指定值，也是先经过node(int index)找到对应下表元素的引用，而后修改Node中item的值。

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

3.三、add方法

一样的，add()方法有两方法，一个是add(E e)，另外一个是add(int index, E element)。

add(E e)方法

该方法在LinkedList的末尾插入元素，由于有last指向链表末尾，在末尾插入元素的花费是常数时间，只须要简单修改几个相关引用便可。

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

/**
 * 添加元素
 */
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++;
}

add(int index, E element)方法

该方法是在指定下表处插入元素，须要先经过线性查找找到具体位置，而后修改相关引用完成插入操做。

具体分红两步，1.先根据index找到要插入的位置；2.修改引用，完成插入操做。

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

        if (index == size)
            //调用add方法，直接在末尾添加元素
            linkLast(element);
        else
            //根据index找到要插入的位置
            linkBefore(element, node(index));
}

/**
 * 插入位置
 */
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++;
}

一样的，添加元素还有另一个addAll()方法，addAll()方法可以一次添加多个元素，根据位置不一样也有两个方法，一个是在末尾添加的addAll(Collection<? extends E> c)方法，另外一个是从指定位置开始插入的addAll(int index, Collection<? extends E> c)方法。

里面也for循环添加元素，addAll()的时间复杂度不只跟插入元素的多少有关，也跟插入的位置相关，时间复杂度是线性增加！

3.四、remove方法

一样的，remove()方法也有两个方法，一个是删除指定下标处的元素remove(int index)，另外一个是删除跟指定元素相等的第一个元素remove(Object o)。

两个删除操做都是，1.先找到要删除元素的引用；2.修改相关引用，完成删除操做。

remove(int index)方法

经过下表，找到对应的节点，而后将其删除

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

remove(Object o)方法

经过equals判断找到对应的节点，而后将其删除

public boolean remove(Object o) {
        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(Node<E> x)方法完成的。这里须要考虑删除元素是第一个或者最后一个时的边界状况。

/**
 * 删除一个Node节点方法
 */
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;
}

4、Vector

Vector类属于一个挽救的子类，早在jdk1.0的时候，就已经存在此类，可是到了jdk1.2以后重点强调了集合的概念，因此，前后定义了不少新的接口，好比ArrayList、LinkedList，但考虑到早期大部分已经习惯使用Vector类，因此，为了兼容性，java的设计者，就让Vector多实现了一个List接口，这才将其保留下来。

在使用方面，Vector的get、set、add、remove方法实现，与ArrayList基本相同，不一样的是Vector在方法上加了线程同步锁synchronized，因此，执行效率方面，会比较慢！

4.一、get方法

public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
}

4.二、set方法

public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
}

4.三、add方法

public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
}

4.四、remove方法

public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
}

5、Stack

在 Java 中 Stack 类表示后进先出（LIFO）的对象堆栈。栈是一种很是常见的数据结构，它采用典型的先进后出的操做方式完成的；在现实生活中，手枪弹夹的子弹就是一个典型的后进先出的结构。

在使用方面，主要方法有push、peek、pop。

5.一、push方法

push方法表示，向栈中添加元素

public E push(E item) {
        addElement(item);
        return item;
}

5.二、peek方法

peek方法表示，查看栈顶部的对象，但不从栈中移除它

public synchronized E peek() {
        int     len = size();
        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
}

5.三、pop方法

pop方法表示，移除元素，并将要移除的元素方法

public synchronized E pop() {
        E       obj;
        int     len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
}

关于 Java 中 Stack 类，有不少的质疑声，栈更适合用队列结构来实现，这使得Stack在设计上不严谨，所以，官方推荐使用Deque下的类来是实现栈！

6、总结

ArrayList(动态数组结构)，查询快（随意访问或顺序访问），增删慢，但在末尾插入，速度与LinkedList相差无几！
LinkedList（双向链表结构），查询慢，增删快！
Vector（动态数组结构），相比ArrayList都慢，被ArrayList替代，基本不在使用。优点是线程安全（函数都是synchronized），若是须要在多线程下使用，推荐使用并发容器中的工具类来操做，效率高！
Stack（栈结构）继承于Vector，数据是先进后出，基本不在使用，若是要实现栈，推荐使用Deque下的ArrayDeque，效率比Stack高！

7、参考

一、JDK1.7&JDK1.8 源码
二、CarpenterLee - Java集合分析
三、博客园 - 朽木 - ArrayList、LinkedList、Vector、Stack的比较

做者：炸鸡可乐
出处：www.pzblog.cn