Java 深入学习（2） —— ArrayList、LinkedList、Vector 应用场景与性能分析

应用场景与性能差异

ArrayList 随机访问较快，增删较慢，线程不安全
LinkedList 增删较快，随机访问较慢，线程不安全
Vector 与 ArrayList 性能相近，但 Vector 线程安全

测试代码

package com.practice.list;

import java.util.*;

public class ListCompare {
    private static final Integer N = 100000;
    private static final Integer LOOP_TIME = 3;
    private static List<Integer> array_list = new ArrayList<>();
    private static List<Integer> vector_list = new Vector<>();
    private static List<Integer> linked_list = new LinkedList<>();
    private static long startTime;
    private static long endTime;
    private static long runtime;

    private static void deleteElement(List list) {
        runtime = 0;
        for (int i = 0; i < LOOP_TIME; i++) {
            startTime = System.currentTimeMillis();   //获取开始时间
            for (int j = 0; j < N; j++) {
                list.remove(0);
            }
            endTime = System.currentTimeMillis(); //获取结束时间
            runtime += (endTime - startTime);
        }
        runtime /= LOOP_TIME;
        System.out.println(getListName(list) + " remove(int index) 删除" +
                "操作运行时间：" + runtime + " ms");
    }

    // 随机访问
    private static void randomVisit(List list) {
        runtime = 0;
        for (int i = 0; i < LOOP_TIME; i++) {
            startTime = System.currentTimeMillis();   //获取开始时间
            for (int j = 0; j < N; j++) {
                list.get((int)(Math.random()*(N-1)));
            }
            endTime = System.currentTimeMillis(); //获取结束时间
            runtime += (endTime - startTime);
        }
        runtime /= LOOP_TIME;
        System.out.println(getListName(list) + " get(int index) 随机访问" +
                "操作运行时间：" + runtime + " ms");
    }

    // 随机位置插入元素
    private static void addElement(List list) {
        runtime = 0;
        for (int i = 0; i < LOOP_TIME; i++) {
            startTime = System.currentTimeMillis();   //获取开始时间
            for (int j = 0; j < N; j++) {
                list.add(0, j);
            }
            endTime = System.currentTimeMillis(); //获取结束时间
            runtime += (endTime - startTime);
        }
        runtime /= LOOP_TIME;
        System.out.println(getListName(list) + " add(int index, Object object) 增加" +
                "操作运行时间：" + runtime + " ms");
    }

    // 顺序访问
    private static void orderVisit(List list) {
        runtime = 0;
        for (int i = 0; i < LOOP_TIME; i++) {
            startTime = System.currentTimeMillis();   //获取开始时间
            for (Object num:list){
                continue;
            }
            endTime = System.currentTimeMillis(); //获取结束时间
            runtime += (endTime - startTime);
        }
        runtime /= LOOP_TIME;
        System.out.println(getListName(list) + " get(int index) 顺序访问" +
                "操作运行时间：" + runtime + " ms");
    }

    // 获取list的名称
    private static String getListName(List list) {
        if (list instanceof LinkedList) {
            return "LinkedList";
        } else if (list instanceof ArrayList) {
            return "ArrayList";
        } else if (list instanceof Vector) {
            return "Vector";
        } else {
            return "List";
        }
    }


    public static void main(String[] args) {

        System.out.println("测试数据量为：" + N + "\r\n" + "求" + LOOP_TIME + "次测试的平均运行时间");
        System.out.println("--------------------------------");

        // 插入元素
        addElement(array_list);     // O(n)
        addElement(vector_list);    // O(n)
        addElement(linked_list);    // O(1)
        System.out.println("--------------------------------");

        // 随机读取
        randomVisit(array_list);    // O(1)
        randomVisit(vector_list);   // O(1)
        randomVisit(linked_list);   // O(n)
        System.out.println("--------------------------------");

        // 顺序读取
        orderVisit(array_list);    // O(1)
        orderVisit(vector_list);   // O(1)
        orderVisit(linked_list);   // O(1)
        System.out.println("--------------------------------");

        // 删除元素
        deleteElement(array_list);      // O(n)
        deleteElement(vector_list);     // O(n)
        deleteElement(linked_list);     // O(1)
        System.out.println("--------------------------------");
    }
}

测试结果

测试数据量为：100000
求3次测试的平均运行时间
--------------------------------
ArrayList add(int index, Object object) 增加操作运行时间：3051 ms
Vector add(int index, Object object) 增加操作运行时间：2786 ms
LinkedList add(int index, Object object) 增加操作运行时间：4 ms
--------------------------------
ArrayList get(int index) 随机访问操作运行时间：7 ms
Vector get(int index) 随机访问操作运行时间：8 ms
LinkedList get(int index) 随机访问操作运行时间：14131 ms
--------------------------------
ArrayList get(int index) 顺序访问操作运行时间：7 ms
Vector get(int index) 顺序访问操作运行时间：14 ms
LinkedList get(int index) 顺序访问操作运行时间：5 ms
--------------------------------
ArrayList remove(int index) 删除操作运行时间：2809 ms
Vector remove(int index) 删除操作运行时间：2807 ms
LinkedList remove(int index) 删除操作运行时间：2 ms
--------------------------------

Process finished with exit code 0

---

ArrayList 与 LinkedList 性能差异分析

---

为什么LinkedList中插入元素很快，而ArrayList中插入元素很慢？

LinkedList.java

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

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

private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

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

从中，我们可以看出：通过add(int index, E element)向LinkedList插入元素时。先是在双向链表中找到要插入节点的位置index；找到之后，再插入一个新节点。双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

ArrayList.java

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

    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

ensureCapacity(size+1)的作用是“确认ArrayList的容量，若容量不够，则增加容量。”

真正耗时的操作是System.arraycopy(elementData, index, elementData, index + 1, size - index);

System.arraycopy(elementData, index, elementData, index + 1, size - index); 会移动index之后所有元素即可。这就意味着，ArrayList的add(int index, E element)函数，会引起index之后所有元素的改变！

“删除元素”与“插入元素”的原理类似。

---

为什么LinkedList中随机访问很慢，而ArrayList中随机访问很快？

LinkedList.java

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

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

从中，我们可以看出：通过get(int index)获取LinkedList第index个元素时。先是在双向链表中找到要index位置的元素；找到之后再返回。双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

ArrayList.java

    public E get(int index) {
        rangeCheck(index);
        checkForComodification();
        return ArrayList.this.elementData(offset + index);
    }

    E elementData(int index) {
        return (E) elementData[index];
    }

从中，我们可以看出：通过get(int index)获取ArrayList第index个元素时。直接返回数组中index位置的元素，而不需要像LinkedList一样进行查找。

---

ArrayList 与 Vector 比较

---

相同之处

---

1 它们都是List

它们都继承于AbstractList，并且实现List接口。
ArrayList和Vector的类定义如下：

// ArrayList的定义
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

// Vector的定义
public class Vector<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

2 它们都实现了RandomAccess和Cloneable接口

   实现RandomAccess接口，意味着它们都支持快速随机访问；
   实现Cloneable接口，意味着它们能克隆自己。

3 它们都是通过数组实现的，本质上都是动态数组

ArrayList.java中定义数组elementData用于保存元素

// 保存ArrayList中数据的数组
private transient Object[] elementData;

Vector.java中也定义了数组elementData用于保存元素

// 保存Vector中数据的数组
protected Object[] elementData;

4 它们的默认数组容量是10

若创建ArrayList或Vector时，没指定容量大小；则使用默认容量大小10。

ArrayList的默认构造函数如下：

// ArrayList构造函数。默认容量是10。
public ArrayList() {
    this(10);
}

Vector的默认构造函数如下：

// Vector构造函数。默认容量是10。
public Vector() {
    this(10);
} 

5 它们都支持Iterator和listIterator遍历

它们都继承于AbstractList，而AbstractList中分别实现了 “iterator()接口返回Iterator迭代器” 和 “listIterator()返回ListIterator迭代器”。

---

不同之处

---

1 线程安全性不一样

ArrayList是非线程安全；

Vector是线程安全的，它的函数都是synchronized的，即都是支持同步的。

ArrayList适用于单线程，Vector适用于多线程。

2 对序列化支持不同

ArrayList支持序列化，而Vector不支持
ArrayList有实现java.io.Serializable接口，而Vector没有实现该接口。

3 构造函数个数不同
ArrayList有3个构造函数，而Vector有4个构造函数。Vector除了包括和ArrayList类似的3个构造函数之外，另外的一个构造函数可以指定容量增加系数。

ArrayList的构造函数如下：

// 默认构造函数
ArrayList()

// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的一半。
ArrayList(int capacity)

// 创建一个包含collection的ArrayList
ArrayList(Collection<? extends E> collection)

Vector的构造函数如下：

// 默认构造函数
Vector()

// capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
Vector(int capacity)

// 创建一个包含collection的Vector
Vector(Collection<? extends E> collection)

// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
Vector(int capacity, int capacityIncrement)

4 容量增加方式不同

逐个添加元素时，若ArrayList容量不足时，“新的容量”=“(原始容量x3)/2 + 1”。

Vector的容量增长与“增长系数有关”，若指定了“增长系数”，且“增长系数有效(即，大于0)”；那么，每次容量不足时，“新的容量”=“原始容量+增长系数”。若增长系数无效(即，小于/等于0)，则“新的容量”=“原始容量 x 2”。

ArrayList中容量增长的主要函数如下：

public void ensureCapacity(int minCapacity) {
    // 将“修改统计数”+1
    modCount++;
    int oldCapacity = elementData.length;
    // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
        if (newCapacity < minCapacity)
            newCapacity = minCapacity;
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

Vector中容量增长的主要函数如下：

private void ensureCapacityHelper(int minCapacity) {
    int oldCapacity = elementData.length;
    // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
    // 若 容量增量系数>0(即capacityIncrement>0)，则将容量增大当capacityIncrement
    // 否则，将容量增大一倍。
    if (minCapacity > oldCapacity) {
        Object[] oldData = elementData;
        int newCapacity = (capacityIncrement > 0) ?
            (oldCapacity + capacityIncrement) : (oldCapacity * 2);
        if (newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

5 对Enumeration的支持不同。Vector支持通过Enumeration去遍历，而List不支持

Vector中实现Enumeration的代码如下：

public Enumeration<E> elements() {
    // 通过匿名类实现Enumeration
    return new Enumeration<E>() {
        int count = 0;

        // 是否存在下一个元素
        public boolean hasMoreElements() {
            return count < elementCount;
        }

        // 获取下一个元素
        public E nextElement() {
            synchronized (Vector.this) {
                if (count < elementCount) {
                    return (E)elementData[count++];
                }
            }
            throw new NoSuchElementException("Vector Enumeration");
        }
    };
}

---

Reference

Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
https://www.cnblogs.com/skywang12345/p/3308900.html

Java数据结构之LinkedList、ArrayList的效率分析
https://www.cnblogs.com/whoislcj/p/6508851.html

---