ArrayList与LinkedList都是线程不安全的，都没有锁的机制
线程安全解决办法 ：
方法1： Collections.synchronizedList(new LinkedList<String>())
方法2: LinkedList和ArrayList换成线程安全的集合，如CopyOnWriteArrayList，ConcurrentLinkedQueue......
方法3：Vector(内部主要使用synchronized关键字实现同步)
ArrayList
1.ArrayList是怎么实现可变长度的，Capacity容量?
看看ArrayList的构造方法：
一般我们创建数组是用下面的方法创建一个空数组。那是怎么给ArrayList定义了一个常量为10的容量呢？
我们看ArrayList的add方法：
调用add方法时会调用ensureCapacityInternal这个方法：
我们可以看到ensureCapacityInternal方法里面，会传入当前数组的长度+1，与默认值DEFAULT_CAPACITY=10比较，取值大的那个，与数组的长度比较，如果add之后的长度超过了数组的长度超，则去调用扩容方法grow：
最后按照新的数组长度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<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> 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<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev; //索引Node对应的前一个Node
final Node<E> 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<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next; //拿到当前索引对应的前一个Node和后一个Node
final Node<E> 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)。
