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()等等。