Java 深入学习(2) —— ArrayList、LinkedList、Vector 应用场景与性能分析
2017-11-28 19:01
891 查看
应用场景与性能差异
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.javapublic 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.javapublic 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
相关文章推荐
- Java 集合系列之 List总结(LinkedList, ArrayLis,vector,stack等使用场景和性能分析)
- java集合--List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java使用Arrays、ArrayList、LinkedList、Vector实现插入查询性能分析
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java集合系列:-----------06List的总结(LinkedList,ArrayList等使用场景和性能分析)
- Java ArrayList、LinkedList和Vector的使用及性能分析
- Java 集合深入学习--ArrayList,LinkedList和Vector
- Java 集合系列 07 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java【集合系列】-08-List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
- List接口实现类-ArrayList、Vector、LinkedList集合深入学习以及源代码解析