Java教程

Java性能调优之ArrayList与LinkedList

本文主要是介绍Java性能调优之ArrayList与LinkedList,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

我们知道ArrayList与LinkedList相比,在插入删除元素方面,LinkedList比ArrayList要快,但真的是这样吗?

在我们对ArrayList与LinkedList进行遍历的时候用for循环好,还是迭代器好?

一、ArrayList

        ArrayList的底层是数据,查询时可以通过下标快速的找到对应的元素。

        进行插入操作时,如果是在队尾,则直接插入;在队中则需要先复制队中到队尾的元素,再插入元素;在对头则需要先复制对头到队尾的元素,再插入元素。

        进行删除操作时,如果是在队尾,则直接删除;在队中则需要先删除元素,再复制队中到队尾的元素;在对头则需要先删除元素,再复制对头到队尾的元素。

二、LinkedList

        LinkedList在jdk1.7之前是双向循环链表,在jdk1.7以后改成了双向非循环链表。

        这样做有几个好处:

        1.LinkedList是通过headerEntry实现的一个循环链表的。先初始化一个空的Entry,用来做header,然后首尾相连,形成一个循环链表。因此非循环链表能够少new一个Entry,减少为空校验,提高效率;

        2.引入了first和last,有了更清晰的队头和队尾的概念;

        3.循环链表在队头或队尾增删元素的时候需要维护两头的指针,而非循环链表只需要处理一头的first.previous/last.next就行,效率更高。

        在查询时,LinkedList需要从头遍历到所需的元素;

        在进行插入和删除操作时,如果是在队头或者队尾,可以直接操作元素进行删除;如果是在队中,则需要从头遍历到对应的元素,再进行操作。(离队头近,从队头开始遍历;离队尾近,从队尾开始遍历。)

三、ArrayList与LinkedList的比较

        1.插入与删除比较

private static void addTailArray(int length){
        ArrayList<Integer> arrayList = new ArrayList<>(length);
        long startArrayTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            arrayList.add(i);
        }
        long endArrayTime = System.currentTimeMillis();
        System.out.println("arrayList队尾插入元素程序运行时间:" + (endArrayTime - startArrayTime) + "ms");
    }

    private static void addHeadArray(int length){
        ArrayList<Integer> arrayList = new ArrayList<>(length);
        long startArrayTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            arrayList.add(0,i);
        }
        long endArrayTime = System.currentTimeMillis();
        System.out.println("arrayList队头插入元素程序运行时间:" + (endArrayTime - startArrayTime) + "ms");
    }

    private static void addMiddleArray(int length){
        ArrayList<Integer> arrayList = new ArrayList<>(length);
        long startArrayTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            arrayList.add(i / 2,i);
        }
        long endArrayTime = System.currentTimeMillis();
        System.out.println("arrayList队中插入元素程序运行时间:" + (endArrayTime - startArrayTime) + "ms");
    }

    private static void addTailLinded(int length){
        LinkedList<Integer> linkedList = new LinkedList<>();
        long startLinkedTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            linkedList.add(i);
        }
        long endLinkedTime = System.currentTimeMillis();
        System.out.println("linkedList队尾插入元素程序运行时间:" + (endLinkedTime - startLinkedTime) + "ms");
    }

    private static void addHeadLinded(int length){
        LinkedList<Integer> linkedList = new LinkedList<>();
        long startLinkedTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            linkedList.addFirst(i);
        }
        long endLinkedTime = System.currentTimeMillis();
        System.out.println("linkedList队头插入元素程序运行时间:" + (endLinkedTime - startLinkedTime) + "ms");
    }

    private static void addMiddleLinded(int length){
        LinkedList<Integer> linkedList = new LinkedList<>();
        long startLinkedTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            linkedList.add(i / 2,i);
        }
        long endLinkedTime = System.currentTimeMillis();
        System.out.println("linkedList队中插入元素程序运行时间:" + (endLinkedTime - startLinkedTime) + "ms");
    }

 我们可以发现,在插入方面的运行时间:

        在队头插入:ArrayList大于LinkedList;

        在队中插入:ArrayList小于LinkedList;

        在队尾插入:ArrayList小于LinkedList。

        队头是因为ArrayList比LinkedList多了一步复制元素,影响效率;队中是因为LinkedList每回都要从头遍历元素,比ArrayList的复制元素更影响效率;队尾是因为LinkedList比ArrayList多了一步new对象以及变换指针,所以效率慢一些。

        大家可以发现,我在new ArrayList的时候初始化了大小。如果没有初始化大小,就会发生扩容,每回扩容都会复制元素,影响效率。但是随着队列的长度越来越大,以上的结果是不变的。因为ArrayList扩容为当前容量的一点五倍,而随着不断的扩容,ArrayList越来越大发生扩容的频率会变低。

        删除的结果以及逻辑是一样的。

        2.遍历比较

public static void main(String[] args) {
        int length = 100000;
        ArrayList<Integer> arrayList = new ArrayList<>(length);
        for (int i = 0; i < length; i++) {
            arrayList.add(i);
        }
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < length; i++) {
            linkedList.add(i);
        }

        long startArrayTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            arrayList.get(i);
        }
        long endArrayTime = System.currentTimeMillis();
        System.out.println("arrayList的for循环运行时间:" + (endArrayTime - startArrayTime) + "ms");

        long startLinkedTime = System.currentTimeMillis();
        for (int i = 0; i < length; i++) {
            linkedList.get(i);
        }
        long endLinkedTime = System.currentTimeMillis();
        System.out.println("linkedList的for循环运行时间:" + (endLinkedTime - startLinkedTime) + "ms");

        Iterator<Integer> arrayIterator= arrayList.iterator();
        Iterator<Integer> linkedIterator = linkedList.iterator();

        long startArrayIteratorTime = System.currentTimeMillis();
        while (arrayIterator.hasNext()){
            arrayIterator.next();
        }
        long endArrayIteratorTime = System.currentTimeMillis();
        System.out.println("arrayList的for循环运行时间:" + (endArrayIteratorTime - startArrayIteratorTime) + "ms");

        long startLinkedIteratorTime = System.currentTimeMillis();
        while (linkedIterator.hasNext()){
            linkedIterator.next();
        }
        long endLinkedIteratorTime = System.currentTimeMillis();
        System.out.println("linkedList的for循环运行时间:" + (endLinkedIteratorTime - startLinkedIteratorTime) + "ms");
    }

        

        我们可以发现:

                ArrayList的for循环效率要远高于ListedList;

                ArrayList的迭代器运行时间跟ListedList几乎一样。

        所以ListedList最好用迭代器遍历,for循环每回都会从头开始遍历。

这篇关于Java性能调优之ArrayList与LinkedList的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!