ArrayList类和LinkedList类对比分析

 测试类

package com.MyLinkedList.test;

import com.ArrayList.ArrayList;
import com.List.List;
import com.MyLinkedList.fulei.LinkedList;

import java.util.Collection;
import java.util.Random;

import static java.lang.System.currentTimeMillis;

public class TestList {

    private static Collection<? extends E> header;

    public static void main(String[] args) {
        testList(new ArrayList<String>());
        testList(new LinkedList<String>());
    }

    private static void testList(ArrayList<String> strings) {
    }

    private static void testList(LinkedList<String> strings) {
    }

    private static void print(String str,long lastTime) {
        System.out.println(str+(System.currentTimeMillis() - lastTime) +"ms" );
    }

    private static int addTest(List<String> list) {
        long lastTime = currentTimeMillis();
        int index = 0;
        for (int i = 10000; i < 20000; i++) {
            list.add("" + i);
            index++;
        }

        print("新增耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 30000; i < 39999; i++){
            list.add(list.size() - 1,""+i);
            index++;
        }
        print("插入到尾耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 20000; i < 29999; i++){
            list.add(list.size() / 2,""+i);
            index++;
        }

        print("插入到中间耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++){
            list.add(0,""+i);
            index++;
        }

        print("插入到头耗时：",lastTime);
        return index;

    }

    public static void removeByObjectTest(List<String> list,int index) {
        long lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++){
            list.remove(""+--index);
        }

        //移除30000~39999
        print("按照对象从尾移除耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++){
            list.remove(""+i);
            index--;
        }

        //移除0~9999
        print("按照对象从头移除耗时：",lastTime);
        int first = Integer.valueOf(list.get(0));
        int last = Integer.valueOf(list.get(list.size()-1));
        int middle = (last - first) / 2 + first;
        boolean flag = true;
        int goLeft = middle;
        int goRight = middle+1;
        lastTime = System.currentTimeMillis();
        for (int i = 0; i <= 10000; i++){
            if (flag){
                flag = false;
                list.remove(""+goLeft--);
            }
            else {
                flag = true;
                list.remove(""+goRight++);
            }
            index--;
        }

        //移除10000~19999之间的10000个数
        print("按照对象从中间移除耗时：",lastTime);

    }

    public static void removeByIndexTest(List<String> list,int index) {
        long lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++){
            list.remove(--index);
        }

        print("按照index从最后移除耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i ++){
            list.remove(list.size() / 2);
            index--;
        }

        print("按照index从中间移除耗时：",lastTime);
        lastTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++){
            index--;
            list.remove(0);
        }

        print("按照index从头移除耗时：",lastTime);
    }

}

运行结果

 class.java.util.ArrayList

新增耗时：9ms

插入到尾耗时：4ms

插入到中间耗时：17ms

插入到头耗时：44ms

按照index从最后移除耗时：1ms

按照index从中间移除耗时：16ms

按照index从头移除耗时：20ms

新增耗时：1ms

插入到尾耗时：2ms

插入到中间耗时：18ms

插入到头耗时：44ms

按照对象从尾移除耗时：1099ms

按照对象从头移除耗时：172ms

按照对象从中间移除耗时：105ms

class.java.util.LinkedList

新增耗时：2ms

插入到尾耗时：3ms

插入到中间耗时：873ms

插入到头耗时：2ms

按照index从最后移除耗时：1ms

按照index从中间移除耗时：921ms

按照index从头移除耗时：0ms

新增耗时：1ms

插入到尾耗时：1ms

插入到中间耗时：811ms

插入到头耗时：1ms

按照对象从尾移除耗时：1994ms

按照对象从头移除耗时：225ms

按照对象从中间移除耗时：109ms

如果仅仅只是需要进行单纯的新增操作，无论ArrayList和LinkedList都适合，但是如果需要对列表两端进行新增操作，那么LinkedList比ArrayList更有效率的多。

如果要对列表的中间部分按照索引进行新增或移除，那么相对而言，ArrayList的效率要高。

不管是ArrayList还是LinkedLisst都要尽量避免直接按照对象进行移除。

测试类

package com.MyLinkedList.test;

import com.ArrayList.ArrayList;
import com.List.List;
import com.MyLinkedList.fulei.LinkedList;

import java.util.Collection;
import java.util.Random;

import static java.lang.System.currentTimeMillis;

public class TestList {

    public static void testList(List<String> list) {
        System.out.println(list.getClass());
        removeByIndexTest(list,addTest(list));
        list.clear();
        removeByObjectTest(list,addTest(list));
    }

    public static void testTest(List<String> list) {
        System.out.println(list.getClass());
        addTest(list);
        getTest(list);
    }

    public static void getTest(List<String> list) {
        Random ran = new Random();
        long lastTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++){
            list.get(ran.nextInt(list.size() - 1));
        }

        print("随机访问：",lastTime);
    }
}

运行结果

class java.util.ArrayList

新增耗时：10ms

插入到尾耗时：4ms

插入到中间耗时：20ms

插入到头耗时：51ms

随机访问：9ms

class java.util.LinkedList

新增耗时：3ms

插入到尾耗时：4ms

插入到中间耗时：837ms

插入到头耗时：2ms

随机访问：6978ms

 随机访问的差距十分明显，由此，可以得出结论：ArrayList的随机访问的效率要高于LinkedList。