- 从线程安全的方面来说，这两个都不能线程安全的；
- 从数据结构来说，ArrayList 的底层使用的是object数组，而LinkedList底层是双向链表数据结构。
- 由于ArrayList是底层是数组，所以可以快速随机访问，通过坐标就可以快速定位，而LinkedList 则不可以。
- 在添加和删除方面，ArrayList 是数组结构，如果添加/删除的是第i个数据，那么数组中的i之后的所有数据都会向前后移动。而链表结构则不会。所以LinkedList做添加删除快速。
- ArrayList会在尾部预留一定的容量空间，因为如果做添加操作的时候，超出当前数组最大值时，会添加50%的空间。LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据
那么有一个问题来了，底层数组的大小不够了怎么办？答案就是扩容，这也就是为什么一直说ArrayList的底层是基于动态数组实现的原因 动态数组的意思就是指底层的数组大小并不是固定的，而是根据添加的元素大小进行一个判断，不够的话就动态扩容，扩容的代码就在grow里面（基于Java7）：
private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1);//当时数组不够用的时候会给新的数组扩容一倍的容量。 if (newCapacity - minCapacity < 0) newCapacity = minCapacity; 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到新数组中。 }
其次再说一下遍历，一般ArrayList优先使用普通for循环。而LinkedList优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环
那么为什么是这样子呢？这是我们普通使用的循环
List<Integer> arrayList = new ArrayList<Integer>();//List<Integer> linkedList = new LinkedList<Integer>();for (int i = 0; i < 100; i++) { arrayList.add(i); } for (int i = 0; i < 100; i++) { System.out.println(arrayList.get(i)); }
如果是普通arrylist 使用for循环 我们从底层代码来看。arrayList就是数组从指定位置上拿数据，假设我们给ArrayList的get方法时间复杂度设为O(1) 那么每一个都是o1。
public E get(int index) { RangeCheck(index); return (E) elementData[index]; }
但是如果是LinkedList 底层是双链表结构，由此看出如果查询的数据 是在前半部分 就循环前面，如果在后半部分就循环后面，
public E get(int index) { return entry(index).element; } private Entry<E> entry(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size); Entry<E> e = header; if (index < (size >> 1)) { for (int i = 0; i <= index; i++) e = e.next; } else { for (int i = size; i > index; i--) e = e.previous; } return e; }
分析一下为什么使用普通for循环遍历LinkedList会这么慢。
以前者为例：
1、get(0)，直接拿到0位的Node0的地址，拿到Node0里面的数据
2、get(1)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，拿到Node1里面的数据
3、get(2)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，从1位的Node1中找到下一个2位的Node2的地址，找到Node2，拿到Node2里面的数据。
后面的以此类推。
也就是说，LinkedList在get任何一个位置的数据的时候，都会把前面的数据走一遍。假如我有10个数据，那么将要查询1+2+3+4+5+5+4+3+2+1=30次数据，相比ArrayList，却只需要查询10次数据就行了，随着LinkedList的容量越大，差距会越拉越大。其实使用LinkedList到底要查询多少次数据，大家应该已经很明白了，来算一下：按照前一半算应该是（1 + 0.5N） * 0.5N / 2，后一半算上即乘以2，应该是（1 + 0.5N） * 0.5N = 0.25N2 + 0.5N，忽略低阶项和首项系数，得出结论，LinikedList遍历的时间复杂度为O(N2)，N为LinkedList的容量。
时间复杂度有以下经验规则：
O(1) < O(log2N) < O(n) < O(N * log2N) < O(N2) < O(N3) < 2N < 3N < N!
前四个比较好、中间两个一般、后3个很烂。也就是说O(N2)是相对糟糕的一种时间复杂度了，N大一点，程序就会执行得比较慢。
并且通过测试得出
| 数据量 | 1000 | 5000 | 10000 | 50000 | 100000 |
| ArrayList | 0ms | 1ms | 2ms | 3ms | 3ms |
| LinkedList | 3ms | 16ms | 88ms | 2446ms | 18848ms |
从运行结果我们看到，按倍数增大List容量，ArrayList的遍历显得比较稳定，而LinkedList的遍历几乎是爆发式的增长，再测试下去已经没有必要了。
另外看到 RandomAccess接口
public interface RandomAccess { }
里面什么都没有定义，那么它其实就是一个标识，用来标识是否具有随机访问功能。
在binarySearch（）方法中，它要判断传入的list 是否RamdomAccess的实例，如果是，调用indexedBinarySearch（）方法，如果不是，那么调用iteratorBinarySearch（）方法
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) { if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD) return Collections.indexedBinarySearch(list, key); else return Collections.iteratorBinarySearch(list, key); }
ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O（n），所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArrayList 实现 RandomAccess 接口才具有快速随机访问功能的！
下面再总结一下 list 的遍历方式选择：
- 实现了RandomAccess接口的list，优先选择普通for循环 ，其次foreach,
- 未实现RandomAccess接口的ist， 优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环
以上内容来自：https://snailclimb.top/JavaGuide/#/./java/collection/Java集合框架常见面试题
http://www.cnblogs.com/xrq730/p/5189565.html
感谢