Linkedlist与ArrayList的各种操作性能对比-单线程对比

为了增加说服力,每一种操作都可以设置重复次数,重复次数越大,求平均的结果越有说服力。这里根据情况设置了1或者10(见main函数的注释)。有时间同学可以设大一些。

先贴结果:

分别对比的是:add(); addlast(); get(); remove() 方法。

insert into arraylist for 10 times cost: 65
insert into linkedlist for 10 times cost: 170 

insert into the last of arraylist for 10 times cost: 180
insert into the last of linkedlist for 10 times cost: 123 

find from arraylist for 1 times cost: 3 

结果分析:

add方法:对比性能较为明显:linkedlist的插入时间明显长一些。

addlast方法:区别不大:从尾部插入至linkedlist时间可能还要短一些(原因有待分析)。

get方法:linkedlist 性能差很多。

remove方法:linkedlist明显优于arraylist。

上一篇从源代码上做了二者简单的分析。这一篇编写单线程代码对比二者性能。

贴代码:

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * Created by aaashen on 2015/4/8.
 */
public class Vs {
    private ArrayList alist = new ArrayList<Integer>();
    private LinkedList llist = new LinkedList<Integer>();
    private long startTime,startTime2 = 0;
    private long endTime,endTime2 = 0;
    private long costTime,totalCostTime = 0;

/*
* @param times
* 求平均的次数
* @param num
* 向list中操作的次数
* */
    private void testArrayInsert(int times, int num) {
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            alist = null;
            alist = new ArrayList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                alist.add(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("insert into arraylist for "+times+" times cost:" + totalCostTime/times);

    }
    private void testLinkedInsert(int times, int num){
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            llist = null;
            llist = new LinkedList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;

            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                llist.add(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("insert into linkedlist for "+times+" times cost:" + totalCostTime/times);
    }

    private void testArrayInsertLast(int times, int num) {
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            alist = null;
            alist = new ArrayList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                alist.add(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("insert into the last of arraylist for "+times+" times cost:" + totalCostTime/times);

    }
    private void testLinkedInsertLast(int times, int num){
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            llist = null;
            llist = new LinkedList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                llist.addLast(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("insert into the last of linkedlist for "+times+" times cost:" + totalCostTime/times);
    }

    private void testArrayFind(int times, int num) {
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            alist = null;
            alist = new ArrayList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            for (int i = 0; i < num; i++) {
                alist.add(i);
            }
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                alist.get(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("find from arraylist for "+times+" times cost:" + totalCostTime/times);

    }
    private void testLinkedFind(int times, int num){
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            llist = null;
            llist = new LinkedList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            for (int i = 0; i < num; i++) {
                llist.add(i);
            }
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num; i++) {
                llist.get(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("find from linkedlist for "+times+" times cost:" + totalCostTime/times);
    }
    /*
    * @param times
    * 求平均的次数
    * @param num
    * 向list中操作的次数
    * @param num_remove
    * 删除的次数
    * */
    private void testArrayRemove(int times, int num, int num_remove) {
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            alist = null;
            alist = new ArrayList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            for (int i = 0; i < num; i++) {
                alist.add(i);
            }
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num_remove; i++) {
                alist.remove(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("remove "+num_remove+" numbers from arraylist for "+times+" times cost:" + totalCostTime/times);

    }
    private void testLinkedRemove(int times, int num, int num_remove){
        long totalCostTime = 0;
        long costTime = 0;
        long startTime = 0;
        long endTime = 0;
        for(int j=0; j<times; j++) {
            llist = null;
            llist = new LinkedList<Integer>();
            costTime = 0;
            startTime = 0;
            endTime = 0;
            for (int i = 0; i < num; i++) {
                llist.add(i);
            }
            startTime = System.currentTimeMillis();
            for (int i = 0; i < num_remove; i++) {
                llist.remove(i);
            }
            endTime = System.currentTimeMillis();
            costTime = endTime - startTime;
            totalCostTime += costTime;

        }
        System.out.println("remove " + num_remove + " numbers from linkedlist for "+times+" times cost:" + totalCostTime/times);
    }

    public static void main(String args[]){

        Vs vs = new Vs();

        //由于不同操作时间长度不同,为了减少等待时间,为同一个参数设置了大小。
        int times_small = 1; //重复次数-小
        int times_large = 10;//重复次数-大
        int num_small = 100000;//操作次数-小
        int num_large = 1000000;//操作次数-大

        //插入操作时间较短,因此设置的都是大的参数,比较有代表性
        vs.testArrayInsert(times_large,num_large);
        vs.testLinkedInsert(times_large,num_large);

        vs.testArrayInsertLast(times_large, num_large);
        vs.testLinkedInsertLast(times_large, num_large);

        //linkedlist删除操作花太久时间,因此传入了小的参数,不影响比较
        vs.testArrayFind(times_small, num_small);
        vs.testLinkedFind(times_small, num_small);

        //删除操作直接设置为1000次删除
        vs.testArrayRemove(times_small, num_small, 1000);
        vs.testLinkedRemove(times_small, num_small, 1000);
}

}

时间: 2024-11-10 08:43:06

Linkedlist与ArrayList的各种操作性能对比-单线程对比的相关文章

多线程对比linkedList和arrayList的add方法

上上一篇对linkedList和arrayList的源码对比:http://blog.csdn.net/aaashen/article/details/44925181 上一篇对linkedList和arrayList的各种方法进行单线程的对比:http://blog.csdn.net/aaashen/article/details/45011365 本篇用多线程对比,之对比add方法,插10000000条数据. 其中arrayList add 数据花费11615,linkedlist add数

JAVA LinkedList和ArrayList的使用及性能分析

第1部分 List概括List的框架图List 是一个接口,它继承于Collection的接口.它代表着有序的队列.AbstractList 是一个抽象类,它继承于AbstractCollection.AbstractList实现List接口中除size().get(int location)之外的函数.AbstractSequentialList 是一个抽象类,它继承于AbstractList.AbstractSequentialList 实现了“链表中,根据index索引值操作链表的全部函数

【Stackoverflow好问题】LinkedList、ArrayList各自的使用场景,如何确认应该用哪一个呢?

问题 LinkedList.ArrayList各自的使用场景是什么,如何确认应该用哪一个呢? 精华回答 一言以蔽之,在大部分情况下,使用ArrayList会好一些. 一.耗时上各有优缺点.ArrayList稍有优势. List只是一个接口,而LinkedList.ArrayList是List的不同实现.LinkedList的模型是双向链表,而ArrayList则是动态数组 首先对比下常用操作的算法复杂度 LinkedList get(int index) : O(n) add(E element

LinkedList和ArrayList的区别

LinkedList和ArrayList的区别 LinkedList和ArrayList的差别主要来自于Array和LinkedList数据结构的不同.如果你很熟悉Array和LinkedList,你很容易得出下面的结论: 1) 因为Array是基于索引(index)的数据结构,它使用索引在数组中搜索和读取数据是很快的.Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大的,因为这需要重排数组中的所有数据. 2) 相对于ArrayList,LinkedList插入是更快的.因为L

Java中LinkedList和ArrayList的区别

首先亮一下他们两个基本区别,面试的时候可以用来和面试官唠嗑啊 1.ArrayList实现了基本动态数组结构,Linked基于链表的结构.链表?什么是链表?答:"链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中指针连接次序实现的"注:此句话通过了科普中国百科科学词条编写与应用工作项目的审核. 2.对于get和set,ArrayList的性能优于LinkedList,因为Linked要移动指针,麻烦的很 3.对于add和remove,LinkedList要优

LinkedList和ArrayList区别

查询 LinkedList查询用的遍历,AyyayList查询用的是数组下标,所以对于查询ArrayList性能高于LinkedList 新增 新增在末尾或者中间就是ArrayList比LinkedList快,如果在最前面就是LinkedList比ArrayList快 测试一下新增在末尾 public static void main(String[] args){          int flag = 100000; ArrayList aList = new ArrayList(flag)

Difference between LinkedList vs ArrayList in Java

source-url LinkedList implements it with a doubly-linked list. ArrayList implements it with a dynamically resizing array. This will lead further differences in performance. Difference between LinkedList vs ArrayList in Java By Lokesh Gupta | Filed Un

LinkedList和ArrayList

ArrayList与LinkedList在底层的实现是不一样的,前者依托于数组,后者依托于链表,与其说是ArrayList与LinkedList的区别不如说是数组与链表的区别. 1.对于数组(ArrayList)而言,随机访问的get比较占优势. 例子: 对于均存放了200000个元素的ArrayList和LinkedList,使用get获取其中元素. int temp=0; System.out.print("ArrayList获取元素的时间\n"); for(int j=0;j&l

JAVA学习第三十五课(常用对象API)- 集合框架(三)—Vector、LinkedList、ArrayList集合演示

集合框架构成图 摘自百度图片 一.Vector集合 演示 虽然Vector已经不常用了,但是还是要了解一下其中的方法 import java.util.ArrayList; import java.util.Enumeration; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.Vector