应用场景与性能差异
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