ArrayList与LinkedList都是线程不安全的，都没有锁的机制

线程安全解决办法：

方法1： Collections.synchronizedList(new LinkedList())

方法2: LinkedList和ArrayList换成线程安全的集合，如CopyOnWriteArrayList，ConcurrentLinkedQueue......

方法3：Vector(内部主要使用synchronized关键字实现同步)

ArrayList

1.ArrayList是怎么实现可变长度的，Capacity容量?

看看ArrayList的构造方法：

WechatIMG17.png

一般我们创建数组是用下面的方法创建一个空数组。那是怎么给ArrayList定义了一个常量为10的容量呢？
我们看ArrayList的add方法：
调用add方法时会调用ensureCapacityInternal这个方法：

WechatIMG18.png

我们可以看到ensureCapacityInternal方法里面，会传入当前数组的长度+1，与默认值DEFAULT_CAPACITY=10比较，取值大的那个，与数组的长度比较，如果add之后的长度超过了数组的长度超，则去调用扩容方法grow：

image.png

最后按照新的数组长度copy一个新的数组赋值给elementData，完成扩容。

梳理一下流程就是：
创建一个容量为0的数组elementData,这个时候去添加add一条数据的时候，会minCapacity = Math.max(10, elementData.lenght+1);elementData.lenght为0 ，所以得到minCapacity=10；
if (minCapacity - elementData.length > 0) grow(minCapacity); 此时满足扩容条件去扩容，

private void grow(int minCapacity) {//minCapacity=10
        // overflow-conscious code
        int oldCapacity = elementData.length;//初始为0
        int newCapacity = oldCapacity + (oldCapacity >> 1);//按1.5倍扩容，新的也为0
        if (newCapacity - minCapacity < 0)//满足这个条件
            newCapacity = minCapacity;//新容量为10
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//copy一个容量为10的赋值给elementData，得到一个最新的长度为10的数组。此方法是耗时的
    }

同理，如果addAll了一个长度超过10的数据，假设是15，则创建的elementData的长度就为addAll之后的长度15。

因此：在使用ArrayList时，如果你能预估大小，最好直接定义初始容量，这样能节省频繁的扩容带来的额外开支。

ArrayList插入数据：

//这个代码功能就是该方法的作用是拷贝一份长度为length的临时数组，将elementData数组中的index到size-1之间的数据拷贝到临时数组中，放入index+1到size的里---->这里add(int index,E e)的用法是将index开始的元素全部后移空出一位，让新元素加入进来
//换句话说就是拷贝一份临时的空数组[]，然后再执行后面的elementData[index] = element;把插入的数据赋值给index位置
    public void add(int index, E element) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        ensureCapacityInternal(size + 1);  // Increments modCount!! 判断是否需要扩容
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//插入数据的核心代码
        elementData[index] = element;
        size++;
    }

remove方法同理,将数组的后面4个依次向前移动一位，然后将数组最后一位置为null。

LinkedList

get()方法

判断index值是否大于总数的一半
如果小于，则从first节点向后遍历，直到找到index节点，然后返回该节点的值。
如果大于，则从last节点向前遍历，直到找到index节点，然后返回该节点的值。

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    Node node(int index) {
        // assert isElementIndex(index);
        if (index < (size >> 1)) {
            Node x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

add()方法

没有指定添加的索引则默认添加在最后一个位置，将链表的first，next互相连接起来
指定索引时：

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else //判断要添加的索引不是最后一个位置时
            linkBefore(element, node(index)); //node(index)找到对应索引的值
    }

    void linkBefore(E e, Node succ) {
        // assert succ != null;
        final Node pred = succ.prev; //索引Node对应的前一个Node
        final Node newNode = new Node<>(pred, e, succ);//插入数据的Node
        succ.prev = newNode;//把索引Node对应的赋值为插入的数据
        if (pred == null) //判断索引Node对应的前一个Node为null,说明是第一个数据，插入数据时把插入的Node赋值给第一个数据
            first = newNode;
        else
            pred.next = newNode; //否则把索引Node对应的前一个Node的next赋值为newNode.
        size++;
        modCount++;
    }

remove()方法

    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

    E unlink(Node x) {
        // assert x != null;
        final E element = x.item;
        final Node next = x.next; //拿到当前索引对应的前一个Node和后一个Node
        final Node prev = x.prev;

        if (prev == null) {//如果前一个Node为null,说明索引是0，则把后一个Node赋值给first
            first = next;
        } else {
            prev.next = next;//否则，把前一个Node的next 赋值为后一个Node
            x.prev = null;
        }

        if (next == null) {//如果后一个Node为null,说明索引是最后一个数据，则把前一个Node赋值给last
            last = prev;
        } else {
            next.prev = prev;//否则，把后一个Node的next 赋值为后一个Node
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

由于LinkedList是一个双向链表，因此不需要扩容机制，直接在前后添加元素即可。

对比
由上面的常用方法可以发现

1.ArrayList使用数组存储元素，因此在查询时速度较快，直接返回该位置的元素即可，时间复杂度为O(1);而LinkedList使用双向链表存储元素，在查询时需要从头或者尾遍历至查询元素，时间复杂度为O(n/2);

2.还是因为存储方式的问题，ArrayList在插入或者删除时，需要移动插入位置之后的所有元素，因此速度较慢，时间复杂度为O(n)。而LinkedList只需要找到该位置，移动”指针”即可,时间复杂度为O(1)。

ArrayList与LinkedList