ArravList，LinkedList，Vector的相同点与区别是什么?

这里是ArrayList、LinkedList和Vector的相同点与区别：
相同点：
1. ArrayList和LinkedList都实现了List接口，都可以存储有序的、可重复的数据。
2. ArrayList和LinkedList都采用了动态数组存储方式，底层都使用了数组来保存数据。
3. Vector和ArrayList都继承了AbstractList抽象类，都实现了List接口。
4. ArrayList和Vector默认初始化大小都是10。

特性列举:

区别：
1. 线程安全性：Vector是线程安全的，而ArrayList和LinkedList是线程不安全的。
2. 扩容方式：ArrayList每次存储时会检查空间大小，不够时会扩充为原来的1.5倍，而Vector会扩充为原来空间的2倍。LinkedList不需要扩容。
3. 插入和删除操作效率：LinkedList对于频繁的插入和删除操作，效率比ArrayList高。
4. 内存空间占用：LinkedList因为要存储前后节点的信息，所以占用的内存空间比ArrayList大。
5. 增长因子：Vector可以设置增长因子，而ArrayList不可以。

ArrayList：动态数组，使用的时候，只需要操作即可，内部已经实现扩容机制。
线程不安全
有顺序，会按照添加进去的顺序排好
基于数组实现，随机访问速度快，插入和删除较慢一点
可以插入null元素，且可以重复
Vector 和前面说的ArrayList很是类似，这里说的也是1.8版本，它是一个队列，但是本质上底层也是数组实现的。同样继承AbstractList，实现了List,RandomAcess,Cloneable, java.io.Serializable接口。具有以下特点：
提供随机访问的功能：实现RandomAcess接口，这个接口主要是为List提供快速访问的功能，也就是通过元素的索引，可以快速访问到。
可克隆：实现了Cloneable接口
是一个支持新增，删除，修改，查询，遍历等功能。
可序列化和反序列化
容量不够，可以触发自动扩容
*最大的特点是：线程安全的，相当于线程安全的ArrayList。
LinkedList：链表结构，继承了AbstractSequentialList，实现了List,Queue,Cloneable,Serializable，既可以当成列表使用，也可以当成队列，堆栈使用。主要特点有：
线程不安全，不同步，如果需要同步需要使用List list = Collections.synchronizedList(new LinkedList());
实现List接口，可以对它进行队列操作
实现Queue接口，可以当成堆栈或者双向队列使用
实现Cloneable接口，可以被克隆，浅拷贝
实现Serializable，可以被序列化和反序列化

底层存储结构不同

ArrayList和Vector底层都是数组结构,而LinkedList在底层是双向链表结构。

 

 

线程安全性不同

  ArrayList和LinkedList都不是线程安全的,但是Vector是线程安全的,其底层是用了大量的synchronized关键字,效率不是很高。 

如果需要ArrayList和LinkedList是线程安全的，可以使用Collections类中的静态方法synchronizedList(），获取线程安全的容器。

默认的大小不同

 ArrayList如果我们创建的时候不指定大小，那么就会初始化一个默认大小为10,DEFAULT_CAPACITY就是默认大小。

private static final int DEFAULT_CAPACITY = 10;

Vector也一样,如果我们初始化,不传递容量大小,什么都不指定，默认给的容量是10： 

    public Vector() {
        this(10);
    }

 增删改查的效率 

理论上，ArrayList和Vector检索元素，由于是数组，时间复杂度是O(1)，在集合的尾部插入或者删除是O(1)，但是其他的地方增加，删除，都是O(n)，因为涉及到了数组元素的移动。但是LinkedList不一样，LinkedList不管在任何位置，插入，删除都是O(1)的时间复杂度，但是LinkedList在查找的时候，是O(n)的复杂度，即使底层做了优化，可以从头部/尾部开始索引（根据下标在前一半还是后面一半）。

如果插入删除比较多，那么建议使用LinkedList，但是它并不是线程安全的，如果查找比较多，那么建议使用ArrayList，如果需要线程安全，先考虑使用Collections的api获取线程安全的容器，再考虑使用Vector。

测试三种结构在头部不断添加元素的结果：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        addArrayList();
        addLinkedList();
        addVector();
    }
    public static void addArrayList(){
        List list = new ArrayList();
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }

    public static void addLinkedList(){
        List list = new LinkedList();
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
    public static void addVector(){
        List list = new Vector();
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
}

测出来的结果，LinkedList最小，Vector费时最多，基本验证了结果：

ArrayList:7715
LinkedList:111
Vector:8106

 测试get的时间性能，往每一个里面初始化10w个数据，然后每次get出来：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        getArrayList();
        getLinkedList();
        getVector();
    }
    public static void getArrayList(){
        List list = new ArrayList();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.get(i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }

    public static void getLinkedList(){
        List list = new LinkedList();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.get(i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
    public static void getVector(){
        List list = new Vector();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.get(i);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
}

测出来的时间如下，LinkedList 执行get操作确实耗时巨大，Vector和ArrayList在单线程环境其实差不多，多线程环境会比较明显，这里就不测试了：

 

ArrayList ： 18
LinkedList ： 61480
Vector ： 21

测试删除操作的代码如下，删除的时候我们是不断删除第0个元素：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        removeArrayList();
        removeLinkedList();
        removeVector();
    }
    public static void removeArrayList(){
        List list = new ArrayList();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.remove(0);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }

    public static void removeLinkedList(){
        List list = new LinkedList();
        for(int i=0;i<100000;i++){
            list.add(0,i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.remove(0);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
    public static void removeVector(){
        List list = new Vector();
        for(int i=0;i<100000;i++){
            list.add(i);
        }
        long startTime = System.nanoTime();
        for(int i=0;i<100000;i++){
            list.remove(0);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1000/60);
    }
}

测试结果，LinkedList确实效率最高，但是Vector比ArrayList效率还要高。因为是单线程的环境，没有触发竞争的关系。

ArrayList: 7177
LinkedList: 34
Vector: 6713

下面来测试一下，vector多线程的环境，首先两个线程，每个删除5w元素：

package com.aphysia.offer;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        removeVector();
    }

    public static void removeVector() {
        List list = new Vector();
        for (int i = 0; i < 100000; i++) {
            list.add(i);
        }
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    list.remove(0);
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    list.remove(0);
                }
            }
        });
        long startTime = System.nanoTime();
        thread1.start();
        thread2.start();
        while (!list.isEmpty()) {

        }
        long endTime = System.nanoTime();
        System.out.println((endTime - startTime) / 1000 / 60);
    }
}

测试时间为：12668

如果只使用一个线程，测试的时间是：8216，这也从结果说明了确实Vector在多线程的环境下，会竞争锁，导致执行时间变长。

总结一下

ArrayList
底层是数组，扩容就是申请新的数组空间，复制
线程不安全
默认初始化容量是10，扩容是变成之前的1.5倍
查询比较快
LinkedList
底层是双向链表，可以往前或者往后遍历
没有扩容的说法，可以当成双向队列使用
增删比较快
查找做了优化，index如果在前面一半，从前面开始遍历，index在后面一半，从后往前遍历。
Vector
底层是数组，几乎所有方法都加了Synchronize
线程安全
有个扩容增长系数，如果不设置，默认是增加原来长度的一倍，设置则增长的大小为增长系数的大小。