ArrayList、LinkedList、Vector、Array

ArrayList 本质是一个数组。

优势：追加元素到数组末尾的时候速度快，同时检索元素的速度也快。

劣势：如果要插入一个元素到数组之间慢；如果要追加的元素数量多于数组的容量，则需要频繁扩容使用Arrays.Arrays.copyOf 重新创建一个合适容量的数组

LinkedList 本质是一个list

优势：追加元素没有容量限制，追加速度快，无论是追加元素到链表哪个位置

劣势：检索元素慢

测试代码如下：

package com.drafire.testall.Sevice;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;

import java.util.Date;

import java.util.LinkedList;

import java.util.Random;

@SpringBootTest

@RunWith(SpringRunner.class)

public class ListClass {

    private final ArrayList arrayList = new ArrayList();

    private final LinkedList linkedList = new LinkedList();

    //初始化容量

    private static int INITIAL_SIZE = 10000000;

    //累计插入元素的次数

    private static int ADD_SIZE = 1000;

    //插入的元素

    private static int ADD_NUM = 3;

    //插入元素的位置

    private static int ADD_INDEX = 988;

    //线程数量

    private static final int THREAD_SIZE = 10;

    //修改元素的位置

    private final int CHANGE_INDEX = 5;

    //测试线程安全

    @Test

    public void testThreadSafe() {

        init();

        testArrayListThreadSafe();

        testLinkedListThreadSafe();

    }

    //测试性能

    @Test

    public void testNature() {

        setArrayList();

        setLinkedList();

        testAddArrayList();

        testAddLinkList();

        testQueryArrayListItem();

        testQueryLinkedListItem();

    }

    private void init() {

        for (int i = 0; i < THREAD_SIZE; i++) {

            arrayList.add(i, THREAD_SIZE + i);

            linkedList.add(i, THREAD_SIZE + i);

        }

    }

    private void testArrayListThreadSafe() {

        MyArrayListThread[] myArrayListThreads = new MyArrayListThread[THREAD_SIZE];

        for (int i = 0; i < THREAD_SIZE; i++) {

            myArrayListThreads[i] = new MyArrayListThread(i);

        }

        for (int i = 0; i < THREAD_SIZE; i++) {

            Thread thread = new Thread(myArrayListThreads[i]);

            thread.start();

        }

        System.out.println("arrayList[" + CHANGE_INDEX + "]=" + arrayList.get(CHANGE_INDEX));

    }

    private void testLinkedListThreadSafe() {

        MyLinkedListThread[] myLinkedListThreads = new MyLinkedListThread[THREAD_SIZE];

        for (int i = 0; i < THREAD_SIZE; i++) {

            myLinkedListThreads[i] = new MyLinkedListThread(i);

        }

        for (int i = 0; i < THREAD_SIZE; i++) {

            //不要调用run方法。因为run()实际上只是跑了主进程一个线程

            Thread thread = new Thread(myLinkedListThreads[i]);

            thread.start();

        }

        System.out.println("linkedList[" + CHANGE_INDEX + "]=" + linkedList.get(CHANGE_INDEX));

    }

    private void setArrayList() {

        Date st = new Date();

        for (int i = 0; i < INITIAL_SIZE; i++) {

            arrayList.add(i);

        }

        Date et = new Date();

        System.out.println("arrayList 初始化使用时间：" + (et.getTime() - st.getTime()));

    }

    private void setLinkedList() {

        Date st = new Date();

        for (int i = 0; i < INITIAL_SIZE; i++) {

            linkedList.add(i);

        }

        Date et = new Date();

        System.out.println("linkedList 初始化使用时间：" + (et.getTime() - st.getTime()));

    }

    private void testAddArrayList() {

        //ArrayList 本质是一个数组。集合的优势在于，追加元素到数组末尾的时候速度快，同时检索元素的速度也快。

        // 但是如果要插入一个元素到数组之间，就慢；另外，如果要追加的元素数量多于数组的容量，则需要频繁扩容

        //使用Arrays.Arrays.copyOf 重新创建一个合适容量的数组

        Date st = new Date();

        for (int i = 0; i < ADD_SIZE; i++) {

            arrayList.add(ADD_INDEX, ADD_NUM);

        }

        Date et = new Date();

        System.out.println("arrayList在" + ADD_INDEX + "处添加元素：" + ADD_NUM + "," + ADD_SIZE + "次，使用时间：" + (et.getTime() - st.getTime()));

    }

    private void testAddLinkList() {

        //LinkedList本质是一个链表。list的优势在于，没有容量的概念，追加元素速度快

        Date st = new Date();

        for (int i = 0; i < ADD_SIZE; i++) {

            linkedList.add(ADD_INDEX, ADD_NUM);

        }

        Date et = new Date();

        System.out.println("linkedList在" + ADD_INDEX + "处添加元素：" + ADD_NUM + "," + ADD_SIZE + "次，使用时间：" + (et.getTime() - st.getTime()));

    }

    private void testQueryArrayListItem() {

        Date st = new Date();

        for (int i = 0; i < ADD_SIZE; i++) {

            arrayList.get(new Random().nextInt(INITIAL_SIZE));

        }

        Date et = new Date();

        System.out.println("arrayList随机检索元素：" + ADD_SIZE + "次，使用时间：" + (et.getTime() - st.getTime()));

    }

    private void testQueryLinkedListItem() {

        Date st = new Date();

        for (int i = 0; i < ADD_SIZE; i++) {

            linkedList.get(new Random().nextInt(INITIAL_SIZE));

        }

        Date et = new Date();

        System.out.println("linkedList随机检索元素：" + ADD_SIZE + "次，使用时间：" + (et.getTime() - st.getTime()));

    }

    private class MyArrayListThread implements Runnable {

        private int value;

        public MyArrayListThread(int v) {

            this.value = v;

        }

        @Override

        public void run() {

            arrayList.set(CHANGE_INDEX, value);

        }

    }

    private class MyLinkedListThread implements Runnable {

        private int value;

        public MyLinkedListThread(int v) {

            this.value = v;

        }

        @Override

        public void run() {

            linkedList.set(CHANGE_INDEX, value);

        }

    }

}

调用testNature()，结果如下：

arrayList 初始化使用时间：4290
linkedList 初始化使用时间：1676
arrayList在988处添加元素：3,1000次，使用时间：6037
linkedList在988处添加元素：3,1000次，使用时间：5
arrayList随机检索元素：1000次，使用时间：7
linkedList随机检索元素：1000次，使用时间：34017

调用testThreadSafe()，结果如下：

arrayList[5]=9
linkedList[5]=8

从上面结果可以看出，ArrayList 和LinkedList 都是非线程安全的

----------------------------------------------------------------------------------------------

关于Vector，Vector的本质也是一个数组，数组的优劣势也是它的优劣势。

看jdk 的源码，发现好多方法都是用synchronized修饰的，想当然，我们认为这个是线程安全的。看下面的测试代码：

package com.drafire.testall.Sevice;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Vector;

@SpringBootTest

@RunWith(SpringRunner.class)

public class VectorClass {

    private final Vector vector = new Vector();

    //修改元素的位置

    private final int CHANGE_INDEX = 5;

    //线程数量

    private static final int THREAD_SIZE = 10;

    //测试线程安全

    @Test

    public void testThreadSafe() {

        for (int i = 0; i < THREAD_SIZE; i++) {

            vector.add(i, THREAD_SIZE + i);

        }

        MyVectorThread[] myVectorThreads = new MyVectorThread[THREAD_SIZE];

        for (int i = 0; i < THREAD_SIZE; i++) {

            myVectorThreads[i] = new MyVectorThread(i);

        }

        for (int i = 0; i < THREAD_SIZE; i++) {

            //不要调用run方法。因为run()实际上只是跑了主进程一个线程

            Thread thread = new Thread(myVectorThreads[i]);

            thread.start();

        }

        System.out.println("vector[" + CHANGE_INDEX + "]=" + vector.get(CHANGE_INDEX));

    }

    private class MyVectorThread implements Runnable {

        private int value;

        public MyVectorThread(int v) { this.value = v; }

        @Override

        public void run() { vector.set(CHANGE_INDEX, value); }

    }

}

多次测试，发现上面输出结果，并非都是我们想象中的：vector[5]=9。这是因为，线程安全，指的是单个操作安全，复合操作有问题（我也不懂什么叫复合操作）。

-----------------------------------------------------------------------------------

数组（Array）和列表（ArrayList）有什么区别

Array可以包含基本类型和对象类型，ArrayList只能包含对象类型

Array大小固定，ArrayList的大小是动态变化的。

ArrayList提供了更多的方法和特性：比如：addAll(),removeAll(),iterator()等等。

巴特西

ArrayList、LinkedList、Vector、Array

最新文章

热门文章