0. 说明

今天无意间看到网上在讨论ArrayList和LinkedList的区别，本文准备从源码中分析下这两个List的底层实现和应用选择。

1. ArrayList

从名称上可以看出来是数组的形式的List，其实代表的是底层实现是数组。所以可以实现随机读取。看下源码

/** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. Any * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA * will be expanded to DEFAULT_CAPACITY when the first element is added. */transient Object[] elementData;```可以大胆猜测内部是以数组的形式实现的，为了验证我们再来看看获得设置某一个元素的方法源码：```javaE elementData(int index) { return (E) elementData[index];}/** * Returns the element at the specified position in this list. * * @param index index of the element to return * @return the element at the specified position in this list * @throws IndexOutOfBoundsException {@inheritDoc} */public E get(int index) { rangeCheck(index); return elementData(index);}/** * Replaces the element at the specified position in this list with * the specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue;}

可见获得元素或者设置元素的方法就是设置数组的方法，而且也是设置elementData属性。

ArrayList有一个比较特别的就是扩容， 看下扩容的源码：

private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity);}/** * The maximum size of array to allocate. * Some VMs reserve some header words in an array. * Attempts to allocate larger arrays may result in * OutOfMemoryError: Requested array size exceeds VM limit */private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;/** * Increases the capacity to ensure that it can hold at least the * number of elements specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */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);}

主要是在grow方法中，int newCapacity = oldCapacity + (oldCapacity >> 1);代码可以得到每次扩容后的容量是上一次容量的1.5倍，先开辟1.5倍的空间，然后再将原来数组中的元素copy到新的数组中，并将list的elementData引用指向新的地址。

图示的办法看下扩容的样子：

ArrayList扩容

红色的位置已经有数据了。

2. LinkedList

看名字也知道，是以链表的形式实现的。内部的数据存储的数据结构是：

/** * Pointer to first node. * Invariant: (first == null && last == null) || * (first.prev == null && first.item != null) */transient Node first;/** * Pointer to last node. * Invariant: (first == null && last == null) || * (last.next == null && last.item != null) */transient Node last;private static class Node { E item; Node next; Node prev; Node(Node prev, E element, Node next) { this.item = element; this.next = next; this.prev = prev; }}

从源码可知是以双向链表的形式实现的。从get,set方法中再验证下：

/** * Returns the element at the specified position in this list. * * @param index index of the element to return * @return the element at the specified position in this list * @throws IndexOutOfBoundsException {@inheritDoc} */public E get(int index) { checkElementIndex(index); return node(index).item;}/** * Replaces the element at the specified position in this list with the * specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */public E set(int index, E element) { checkElementIndex(index); Node x = node(index); E oldVal = x.item; x.item = element; return oldVal;}/** * Returns the (non-null) Node at the specified element index. */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; }}

定位查找的方法主要是node方法，明显是双向链表，当所以是后半部分的时候，从结尾开始遍历，如果是前半部分，则从头部开始遍历。而链表形式，理论上链表可以无限长，所以，在LinkedList中不存在扩容的问题。

我们看下存储的图示：

LinkedList

3. 比较

其实性能问题主要就是数组和链表的性能区别。

1. - arraylist
2. - 优点
3. - 随机访问，get(i)的时间复杂度为O(1)
4. - 缺点
5. - 需要扩容，复制数组
6. - 内部插入数据需要移动数据，插入删除的性能差
7. - LinkedList
8. - 优点
9. - 容量理论无限，不存在扩容
10. - 可以很方便的插入和删除数据(性能损失在查找)
11. - 缺点
12. - 不能随机访问，get(i)需要遍历

可见，两个的优缺点正好相反，从而在实际使用中要根据自己的也许决定使用那个list。

注意，这里面有几个方法，就是contain(Object o), indexOf(Object O)，这些方法，也是必须的一个一个遍历的，复杂度是O(n)。在LinkedList中的get(i)方法内，使用双向链表的方法，可以将平均复杂度为n/2降低为n/4.

这里还有一个思想就是，List元素的数量专门用一个字段size来存储，非常方便，但是有可能出现数据不一致(在多线程编程中)，这种为了方便或者说提高性能而数据冗余的方法，在实际的开发中也会用到，这个字段也为上面的get(i), add()方法提供了很大遍历。

@Testpublic void test_list_get() { List list = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("String" + ++i); } long start = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { String str = list.get(30);// System.out.println(str); } long end = System.currentTimeMillis(); System.out.println("耗时：" + (end - start)); list = new LinkedList<>(); for (int i = 0; i < 1000; i++) { list.add("String" + ++i); } start = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { String str = list.get(30);// System.out.println(str); } end = System.currentTimeMillis(); System.out.println("耗时：" + (end - start));}@Testpublic void test_list_set() { List list = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add("String" + i); } long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { list.add(100, "String" + (100+i)); } long end = System.currentTimeMillis(); System.out.println("耗时：" + (end - start)); list = new LinkedList<>(); for (int i = 0; i < 1000; i++) { list.add("String" + i); } start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { list.add(100, "String" + (100+i)); } end = System.currentTimeMillis(); System.out.println("耗时：" + (end - start));}

两个方法的运行结果是：

耗时：19耗时：209耗时：597耗时：30

可以验证我们上面讲的。

当然，List的不同实现使用了不同的原理，本文只是简单的介绍了ArrayList和LinkedList的部分原理，具体各位读者可以自己研究，也欢迎评论区交流。

求**评论、点赞、关注+转发**

限于笔者知识有限，如果不足之处请帮忙指正，不喜勿喷！

您的支持是我不懈努力的动力，请读者多支持下！

更多文章，请关注微信公众号 CS_Toper之路，或者头条号 CSToper。