Vector、ArrayList、LinkedList的增删查效率对比

1.Vector,ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
2.访问集合数据，LinkedList要移动指针，从一端向另一端查找，效率很低。 
3.新增和删除操作add和remove，对于linkedList开销是统一的，分配一个Entry对象；但对于Vector和ArrayList，在尾端操作数据，开销是固定的，但是如果不是在尾端，可能会导致数组重新分配，而且结尾会预留一定的容量空间。

package list;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class listT1 {
　　public static void main(String[] args) {
　　　　List<Integer> vector = new Vector<Integer>();
　　　　List<Integer> arrayList = new ArrayList<Integer>();
　　　　List<Integer> linkedList = new LinkedList<Integer>();
　　　　int listSize = 50000;
　　　　int searchOrRemoveSize = 2000;
　　　　long vectorStartTime = 0;
　　　　long vectorEndTime = 0;
　　　　long arrayListStartTime = 0;
　　　　long arrayListEndTime = 0;
　　　　long linkedListStartTime = 0;
　　　　long linkedListEndTime = 0;
　　　　String[] listType = { "vector", "arrayList", "linkedList" };
　　　　long[][] listData = new long[3][4];
　　　　/** 向后依次新增测试 start */
　　　　vectorStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　vector.add(i);
　　　　}
　　　　vectorEndTime = System.currentTimeMillis();
　　　　listData[0][0] = vectorEndTime - vectorStartTime;

　　　　arrayListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　arrayList.add(i);
　　　　}
　　　　arrayListEndTime = System.currentTimeMillis();
　　　　listData[1][0] = arrayListEndTime - arrayListStartTime;

　　　　linkedListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　linkedList.add(i);
　　　　}
　　　　linkedListEndTime = System.currentTimeMillis();
　　　　listData[2][0] = linkedListEndTime - linkedListStartTime;
　　　　/** 向后依次新增测试 end */

　　　　/** 在最前端新增测试 start */
　　　　vectorStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　vector.add(0, i);
　　　　}
　　　　vectorEndTime = System.currentTimeMillis();
　　　　listData[0][1] = vectorEndTime - vectorStartTime;

　　　　arrayListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　arrayList.add(0, i);
　　　　}
　　　　arrayListEndTime = System.currentTimeMillis();
　　　　listData[1][1] = arrayListEndTime - arrayListStartTime;

　　　　linkedListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < listSize; i++) {
　　　　　　linkedList.add(0, i);
　　　　}
　　　　linkedListEndTime = System.currentTimeMillis();
　　　　listData[2][1] = linkedListEndTime - linkedListStartTime;
　　　　/** 在最前端新增测试 end */

　　　　/** 检索测试 start */
　　　　vectorStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　vector.get(i);
　　　　}
　　　　vectorEndTime = System.currentTimeMillis();
　　　　listData[0][2] = vectorEndTime - vectorStartTime;

　　　　arrayListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　arrayList.get(i);
　　　　}
　　　　arrayListEndTime = System.currentTimeMillis();
　　　　listData[1][2] = arrayListEndTime - arrayListStartTime;

　　　　linkedListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　linkedList.get(i);
　　　　}
　　　　linkedListEndTime = System.currentTimeMillis();
　　　　listData[2][2] = linkedListEndTime - linkedListStartTime;
　　　　/** 检索测试 end */

　　　　/** 删除测试 start */
　　　　vectorStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　vector.remove(i);
　　　　}
　　　　vectorEndTime = System.currentTimeMillis();
　　　　listData[0][3] = vectorEndTime - vectorStartTime;

　　　　arrayListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　arrayList.remove(i);
　　　　}
　　　　arrayListEndTime = System.currentTimeMillis();
　　　　listData[1][3] = arrayListEndTime - arrayListStartTime;

　　　　linkedListStartTime = System.currentTimeMillis();
　　　　for (int i = 0; i < searchOrRemoveSize; i++) {
　　　　　　linkedList.remove(i);
　　　　}
　　　　linkedListEndTime = System.currentTimeMillis();
　　　　listData[2][3] = linkedListEndTime - linkedListStartTime;
　　　　/** 删除测试 end */

　　　　for (int i = 0; i < listData.length; i++) {
　　　　　　long[] arr = listData[i];
　　　　　　System.out.print(listType[i] + "向后增加（" + listSize + "）、 在最前增加（"
　　　　　　　　+ listSize + "）、检索（" + searchOrRemoveSize + "）、删除（"
　　　　　　　　+ searchOrRemoveSize + "）条数据消耗的时间（毫秒）：");
　　　　　　for (int j = 0; j < arr.length; j++) {
　　　　　　　　System.out.print(arr[j] + " ");
　　　　　　}
　　　　　　System.out.println();
　　　　}
　　　　/**
　　　　* 调整集合大小，部分结果：
　　　　* vector向后增加（100000）、 在最前增加（100000）、检索（5000）、删除（5000）条数据消耗的时间（毫秒）：17 13638 0 895
　　　　* arrayList向后增加（100000）、 在最前增加（100000）、检索（5000）、删除（5000）条数据消耗的时间（毫秒）：25 14224 0 898 
　　　　* linkedList向后增加（100000）、 在最前增加（100000）、检索（5000）、删除（5000）条数据消耗的时间（毫秒）：44 16 36 71
　　　　* 
　　　　* 
　　　　* vector向后增加（50000）、 在最前增加（50000）、检索（2000）、删除（2000）条数据消耗的时间（毫秒）：7 3443 0 183 
　　　　* arrayList向后增加（50000）、 在最前增加（50000）、检索（2000）、删除（2000）条数据消耗的时间（毫秒）：7 3507 0 187 
　　　　* linkedList向后增加（50000）、 在最前增加（50000）、检索（2000）、删除（2000）条数据消耗的时间（毫秒）：8 43 6 11 
　　　　*  
　　　　*/
　　}
}

　　当操作是在一列数据的后面添加数据而不是在前面或中间（集合容量1/5左右）,并且需要随机地访问其中的元素时,使用Vector(线程安全),ArrayList会提供比较好的性能；

　　当你的操作是在一列数据的前面或中间（集合容量1/5左右）添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

转载于:https://www.cnblogs.com/wcj112/p/3573794.html