android arraylist拷贝,Android 中的ArrayList & LinkedList

前言

通过之前的《数据表-线性结构》。我们已经了解了数据结构中线性表这种存储结构的特点，并就其顺序存储和链式存储的优缺点，及实现方式做了深入的分析，并做了简单的实现；这里我们就从日常开发中常用的ArrayList和LinkedList出发，巩固学习一下线性表这种数据结构。

下面就从线性表的ADT出发，结合其构造函数，常用的增删改查方法的实现，比较一下两种存储结构的特点。

以下源码内容源自于Android SDK API(api-level 25)，部分方法的实现和普通的Java JDK中的实现会有一些出入；日常开发中，API的实现必然是以Android SDK 为主，所以还是从Android SDK 内自带的实现出发分析。

ArrayList

ArrayList本质上就是一个动态数组。

初始化及构造函数

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

{

private static final long serialVersionUID = 8683452581122892189L;

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

transient Object[] elementData;

private int size;

public ArrayList(int initialCapacity) {

super();

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal Capacity: "+

initialCapacity);

this.elementData = new Object[initialCapacity];

}

public ArrayList() {

super();

this.elementData = EMPTY_ELEMENTDATA;

}

public ArrayList(Collection extends E> c) {

elementData = c.toArray();

size = elementData.length;

// c.toArray might (incorrectly) not return Object[] (see 6260652)

if (elementData.getClass() != Object[].class)

elementData = Arrays.copyOf(elementData, size, Object[].class);

}

}

构造函数的实现，很容易理解；这里需要注意以下，我们可以使用其他的集合初始化ArrayList，本质上就是把一个集合中的内容复制到一个数组中。c.toArray实现了列表集合到数组的转换，Arrays.copyOf就是数组的拷贝。当然，这个过程不一定会成功，当失败的时候，会由Arrays.copyOf内部抛出NullPointerException。

增、删、改、查 的实现

增

既然是一个动态数组，那么他是怎样实现动态增长的呢？

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!

elementData[size++] = e;

return true;

}

private void ensureCapacityInternal(int minCapacity) {

if (elementData == EMPTY_ELEMENTDATA) {

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

ensureExplicitCapacity(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;

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);

}

private static int hugeCapacity(int minCapacity) {

if (minCapacity < 0) // overflow

throw new OutOfMemoryError();

return (minCapacity > MAX_ARRAY_SIZE) ?

Integer.MAX_VALUE :

MAX_ARRAY_SIZE;

}

可以看到，对于数组的大小何时改变，如何改变，有着非常严格的规则。

对于空数组，第一次添加元素时，数组大小将变化为 DEFAULT_CAPACITY，也就是10的大小，add操作，总是将元素添加到数组最后。

当我们不断添加元素，动态数组的size大于DEFAULT_CAPACITY时，例如我们添加了第11个元素，此时在grow方法中，

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + (oldCapacity >> 1);

最终，newCapacity 的值为elementData.length的1.5倍，也就是15，因此，此时数组大小将变化为15。也就是说，正常情况下，ArrayList每次扩容，都将会在原来的基础上，增加50%的大小。

如果数组不断的增长，当我们按增长50%的规律扩容后，如果newCapacity大于MAX_ARRAY_SIZE时，此时数组最大的长度为Integer.MAX_VALUE。

删

public E remove(int index) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

modCount++;

E oldValue = (E) elementData[index];

int numMoved = size - index - 1;

if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,

numMoved);

elementData[--size] = null; // clear to let GC do its work

return oldValue;

}

相较于添加一个元素来说，删除一个特定位置的元素就简单多，按照位置关系把数组元素整体(复制)移动一遍，然后将特定位置的引用指向null即可;当然，也可以按照元素的值，从数组中移除元素，或者清空数组，本质上都是一样的工作，就不赘述了。

通过以上内容可以看到，为了方便实现数组的复制操作，这里Arrays.copy 和System.arraycopy 方法，Arrays.copy 在上一篇Java工具类之Arrays梳理中已经介绍过了，System.arraycopy是其内部实现。

改 & 查

public E set(int index, E element) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

E oldValue = (E) elementData[index];

elementData[index] = element;

return oldValue;

}

public E get(int index) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

return (E) elementData[index];

}

由于实现了RandomAccess接口，因此随机访问数组元素是一件特定容易的事情，修改变得so easy，根据数组下标赋值操作，小学生都看得懂了。因此，可以看到对ArrayList，修改和查找是一件十分容易的事情。

批量操作

批量添加

对于动态数组的批量添加操作，和单个元素的操作是没有多少区别的，无非就是进行扩容操作，复制和移动数组元素时，确定好各自的位置就可以了。

public boolean addAll(int index, Collection extends E> c) {

if (index > size || index < 0)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

Object[] a = c.toArray();

int numNew = a.length;

ensureCapacityInternal(size + numNew); // Increments modCount

int numMoved = size - index;

if (numMoved > 0)

System.arraycopy(elementData, index, elementData, index + numNew,

numMoved);

System.arraycopy(a, 0, elementData, index, numNew);

size += numNew;

return numNew != 0;

}

在ArrayList的特定位置，添加一组数据，可以看到关键点都是数组元素的复制。这个时候ensureCapacityInternal的参数，就有可能是一个非常大的值，参考前面add()方法中的扩容操作，这种情况下，一次性可能需要将数组扩大很多。

批量移除

对于批量移除,ArrayList提供了两个使用的方法：

public boolean removeAll(Collection> c) {

return batchRemove(c, false);

}

从当前的ArrayList集合中移除所有包含在集合c中的元素。

public boolean retainAll(Collection> c) {

return batchRemove(c, true);

}

从当前的ArrayList集合中移除所有不在集合c中的元素，换句话说，就是保留两个集合中共有的元素。

可以说，这两个方法实现的操作是互斥的。而他们内部实现都是batchRemove，我们可以看一下。

private boolean batchRemove(Collection> c, boolean complement) {

final Object[] elementData = this.elementData;

int r = 0, w = 0;

boolean modified = false;

try {

for (; r < size; r++)

if (c.contains(elementData[r]) == complement)

elementData[w++] = elementData[r];

} finally {

// Preserve behavioral compatibility with AbstractCollection,

// even if c.contains() throws.

if (r != size) {

System.arraycopy(elementData, r,

elementData, w,

size - r);

w += size - r;

}

if (w != size) {

// clear to let GC do its work

for (int i = w; i < size; i++)

elementData[i] = null;

modCount += size - w;

size = w;

modified = true;

}

}

return modified;

}

这里使用contains方法，实现了元素的筛选。根据if语句，只有当complement为true时，也就是执行retainAll()方法时，w才会累加；需要注意的是，如果两个集合中的元素不兼容，contains()方法会抛出异常，因此会导致循环提前跳出。

最终都会执行到finally语句，在这里

当运行retainAll()方法，循环正常执行完毕时，w=r=size;两个if 判断都不会执行，恰好保存了两个集合中共有的元素；当循环操作异常跳出时，w=r

当运行removeAll()方法，循环正常执行完毕时，r=size,w=0;后一个if 判断中，通过循环所有元素置null，恰好实现了所有元素清空的操作；当循环异常跳出时，r

可以看的，这个算法的实现很是巧妙。好了，ArrayList的内容，就告一段落，下面看看LinkedList。

LinkedList

在《数据表-线性结构》中我们说过，对于数据的链式存储结构，有单链表，循环链表，双向链表，静态链表四种实现，而LinkedList 就是以双向循环链表双向链表的方式实现。

这里需要注意的是，这里的LinkedList是双向链表，但并不是首位相连接的循环链表。

为了方便，我们可以看看下面这幅图，回想一下一个双向链表有哪些关键点，如何实现它的增删改查操作。

双向链表.jpg

初始化及构造函数

java 里面没有指针的概念，对象指向严格来说应该是引用。但是感觉指针这个词，能更加形象的描述其作用。因此，以下对象的引用统一用指针来代替

链式存储结构的实现，需要一个结点对象，因此首先可以看一下结点类的定义。

包含前驱&后继指针的Node

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;

}

}

可以发现，通过构造函数，就可以创建一个结点，第一个参数为指向前驱的结点，第二个参数为当前结点的值，最后一个参数为指向后继的结点。

下面看看LinkedList是如何初始化的

public class LinkedList

extends AbstractSequentialList

implements List, Deque, Cloneable, java.io.Serializable

{

transient int size = 0;

transient Node first;

transient Node last;

/**

* Constructs an empty list.

*/

public LinkedList() {

}

public LinkedList(Collection extends E> c) {

this();

addAll(c);

}

}

可以看到，LinkedList初始化空链表的操作很简单。

增、删、改、查 的实现

增 & 删

双向链表，由于其结构的特殊性，因此不同于数组，只能在最后添加元素的特性，链表可以在其头部，位置，中间任何位置添加元素,只要能把双向链表串起来，怎么都行。

在非空结点succ之前插入元素e

/**

* Inserts element e before non-null Node succ.

*/

void linkBefore(E e, Node succ) {

// assert succ != null;

final Node pred = succ.prev;

final Node newNode = new Node<>(pred, e, succ);

succ.prev = newNode;

if (pred == null)

first = newNode;

else

pred.next = newNode;

size++;

modCount++;

}

对于链表的操作，永远都是那个套路，不要搞错先后顺序，其实很简单。

双向链表插入.png

结合这幅图，链表插入应该很容易理解了。

对于链表中结点的删除，也是同样的道理。

/**

* Unlinks non-null node x.

*/

E unlink(Node x) {

// assert x != null;

final E element = x.item;

final Node next = x.next;

final Node prev = x.prev;

if (prev == null) {

first = next;

} else {

prev.next = next;

x.prev = null;

}

if (next == null) {

last = prev;

} else {

next.prev = prev;

x.next = null;

}

x.item = null;

size--;

modCount++;

return element;

}

这里双向链表中的结点移除后，还需要判断一下，是否需要初始化为一个空的双向链表。

改 & 查

public E get(int index) {

checkElementIndex(index);

return node(index).item;

}

public E set(int index, E element) {

checkElementIndex(index);

Node x = node(index);

E oldVal = x.item;

x.item = element;

return oldVal;

}

链表的修改和查找操作，首先进行的是位置index的越界检测，然后通过node 方法获取index 位置元素进行相应的操作即可。下面看一下node实现。

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;

}

}

可以看到，这里首先会判断一下index位置和整个线性表长度的关系，然后决定是从头部开始后继查找，还是从尾部进行前驱查找。很明显，链式存储结构中，对于查找特定位置的元素，是非常麻烦的。无论怎样，按位置查找，在最坏的情况下，要把一段的元素循环一遍。这在数量级很大的时候，是不划算的。

除了按位置查找之外，还可以按照元素的值进行查找：

public int indexOf(Object o) {

int index = 0;

if (o == null) {

for (Node x = first; x != null; x = x.next) {

if (x.item == null)

return index;

index++;

}

} else {

for (Node x = first; x != null; x = x.next) {

if (o.equals(x.item))

return index;

index++;

}

}

return -1;

}

这个时候，最后情况下，要把所有元素都遍历一遍。

批量操作

批量添加

public boolean addAll(int index, Collection extends E> c) {

checkPositionIndex(index);

Object[] a = c.toArray();

int numNew = a.length;

if (numNew == 0)

return false;

Node pred, succ;

if (index == size) {

succ = null;

pred = last;

} else {

succ = node(index);

pred = succ.prev;

}

for (Object o : a) {

@SuppressWarnings("unchecked") E e = (E) o;

Node newNode = new Node<>(pred, e, null);

if (pred == null)

first = newNode;

else

pred.next = newNode;

pred = newNode;

}

if (succ == null) {

last = pred;

} else {

pred.next = succ;

succ.prev = pred;

}

size += numNew;

modCount++;

return true;

}

从源码可以看到，使用链表结构批量添加元素是很费劲的，首先集合元素转成数组，然后根据添加位置确定结点，最后还要通过循环逐一将数组中元素串进去。

对于链表的清空操作，clear()方法，同理也需要循环各个元素，释放结点的引用，保证链表清空后，所有对象都能被回收。

其他

如果查看LinkedList的源码，我们还可以发现有peek,push,pop等一系列的方法，这是因为LinkedList同时也是一种特殊的线性表-队列。这点从其定义也可以看出来 ，他实现了Deque接口，因此是一个双端队列。这些方法都是按照队列FILO的思想，对双向链表，实现入队出队的操作；内部的真正实现还是依赖于上面提到几个方法，就不赘述了，有兴趣的同学可以对比一下。

以上，从数据结构的角度，叙述了一下ArrayList和LinkedList。注意不是从集合Collections框架的角度出发，所以暂时略过迭代器Iterator的分析。

ArrayList VS LinkedList

关于二者各自的优缺点，适合在哪些场景使用，通过通篇的描述，相信大家心里都有数了。这里就不再总结了。下面再看一下两个常用的点。

判断空

这两种不同的存储结构，是如何实现空判断的呢？

ArrayList

public boolean isEmpty() {

return size == 0;

}

LinkedList 虽然没有提供明确方法，但我们也可以根据其size做判断的。

toArray

通过Arrays 内部的静态方法asList 可以很方便的把数组转换为列表。而List接口也定义的统一的方法toArray实现列表到数组的转换；需要由每一种特殊的List提供各自的实现。我们可以看一下ArrayList和LinkedList是如何实现toArray方法的。

ArrayList-toArray()

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

LinkedList-toArray()

public Object[] toArray() {

Object[] result = new Object[size];

int i = 0;

for (Node x = first; x != null; x = x.next)

result[i++] = x.item;

return result;

}

很清楚的实现，对于ArrayList，本身即是一个数组，因此只需要把内容复制一份即可(可以看到，列表其实也是数组)。而对于LinkedList就稍微有点麻烦了，他需要创建一个对象数组，把列表里的每一个结点的值取出来。

ArrayList VS Vector

说完了ArrayList和LinkedList，这里再简单的说一下Vector。

Vector和ArrayList一样，也是一个动态数组。唯一不同的是Vector是线程安全的，这点从他的源码可以看到，所有的数组操作方法都加了关键字synchronized。因此，当多线程同时操作一个List时，可以考虑使用Vector代替ArrayList。

前面说了，ArrayList每次扩容，会增加原来50%的容量，Vector则是直接增加一倍。

private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + ((capacityIncrement > 0) ?

capacityIncrement : oldCapacity);

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

if (newCapacity - MAX_ARRAY_SIZE > 0)

newCapacity = hugeCapacity(minCapacity);

elementData = Arrays.copyOf(elementData, newCapacity);

}

好了，通过以上对ArrayList和LinkedList的分析，对比；相信大家对线性表的线性存储和链式存储有了更深入的认识。

不成熟的小实验

最后，通过一个不成熟的小实验，ArrayList，Vector，LinkedList PK 一下！！

public class DataStructTest {

private static final int DATA_SIZE = 10 * 10 * 10 * 10 * 10 * 10 * 10;

public static void main(String[] args) {

ArrayListTest();

VectorTest();

LinkedListTest();

}

private static void ArrayListTest() {

long start = System.nanoTime();

List datas = new ArrayList<>();

for (int i = 0; i < DATA_SIZE; i++) {

datas.add("item-" + i);

}

long end = System.nanoTime();

System.err.printf("ArrayList Add %d element in %d nanoseconds\n", DATA_SIZE, (end - start));

start = System.nanoTime();

String data = datas.get(DATA_SIZE / 2);

end = System.nanoTime();

System.err.printf("Get data %s from ArrayList at pos=%d in %d nanoseconds\n", data, DATA_SIZE / 2, end - start);

}

private static void VectorTest() {

long start = System.nanoTime();

List datas = new Vector<>();

for (int i = 0; i < DATA_SIZE; i++) {

datas.add("item-" + i);

}

long end = System.nanoTime();

System.err.printf("Vector Add %d element in %d nanoseconds\n", DATA_SIZE, end - start);

start = System.nanoTime();

String data = datas.get(DATA_SIZE / 2);

end = System.nanoTime();

System.err.printf("Get data %s from Vector at pos=%d in %d nanoseconds\n", data, DATA_SIZE / 2, end - start);

}

private static void LinkedListTest() {

long start = System.nanoTime();

List datas = new LinkedList<>();

for (int i = 0; i < DATA_SIZE; i++) {

datas.add("item-" + i);

}

long end = System.nanoTime();

System.err.printf("LinkedList Add %d element in %d nanoseconds\n", DATA_SIZE, end - start);

start = System.nanoTime();

String data = datas.get(DATA_SIZE / 2);

end = System.nanoTime();

System.err.printf("Get data %s from LinkedList at pos=%d in %d nanoseconds\n", data, DATA_SIZE / 2, end - start);

}

}

上面的代码，使用三种结构实现添加DATA_SIZE个数据到List中，最后从第DATA_SIZE/2个位置返回元素。当然这样对LinkedList来说是不太公平的。总之，这是一个不成熟的小实验。看一下返回结果吧！

ArrayList Add 10000000 element in 7491830924 nanoseconds

Get data item-5000000 from ArrayList at pos=5000000 in 7106 nanoseconds

Vector Add 10000000 element in 3810582375 nanoseconds

Get data item-5000000 from Vector at pos=5000000 in 3948 nanoseconds

LinkedList Add 10000000 element in 3475231051 nanoseconds

Get data item-5000000 from LinkedList at pos=5000000 in 73783797 nanoseconds

这是运行结果，当然每次运行的结果都是不一样的，但是总的趋平均计算的话每次都是相同的。

ArrayList 和 Vector 这样的线性存储结构中，查找某个特定位置的元素是，速度比LinkedList快了差不多一万倍，而添加操作时，LinkedList总的来说，会快一些。

好了，从数据结构的角度说ArrayList和LinkedList就到这里了。

如果本文中有不正确的结论、说法，请大家提出和我讨论，共同进步，谢谢。