Java集合关于ArrayList

ArrayList实现源码分析

2016-04-11 17:52 by 淮左, 207 阅读, 0 评论, 收藏, 编辑

本文将以以下几个问题来探讨ArrayList的源码实现
1.ArrayList的大小是如何自动增加的
2.什么情况下你会使用ArrayList？什么时候你会选择LinkedList？
3.如何复制某个ArrayList到另一个ArrayList中去？写出你的代码？
4.在索引中ArrayList的增加或者删除某个对象的运行过程？效率很低吗？解释一下为什么？
5.Interator在ArrayList的实现

关于Java集合的小抄 关于ArrayList的描述：
以数组实现。节约空间，但数组有容量限制。超出限制时会增加50%容量，用System.arraycopy()复制到新的数组，因此最好能给出数组大小的预估值。默认第一次插入元素时创建大小为10的数组。
按数组下标访问元素--get(i)/set(i,e) 的性能很高，这是数组的基本优势。
直接在数组末尾加入元素--add(e)的性能也高，但如果按下标插入、删除元素--add(i,e), remove(i), remove(e)，则要用System.arraycopy()来移动部分受影响的元素，性能就变差了，这是基本劣势。

1、ArrayList的大小是如何自动增加的

直接上代码吧，每次add的时候都会判断是否需要扩容，以下是扩容的主要方法

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

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//左移1位，相当于除以2，就是容量提高50%
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//最大的阀值MAX_ARRAY_SIZE
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);
}

2、什么情况下你会使用ArrayList？什么时候你会选择LinkedList？

我们知道ArrayList和LinkedList的数据结构是不同的，ArrayList是以连续的数组进行存储的，所以它的get是常数级别的，LinkedList是双向链表存储的。他的查询最坏情况是n。以为ArrayList是数组存储的，所以当你查找某一指定索引的数据时，它每次删除和指定索引添加都要移动数组的位置，其内部的实现方式是数组复杂用到System.arraycope，是比较影响性能的，而双向链表删除和插入只要找到相应的节点位置，关联下指针，所以性能会更好。

public void add(int index, E element) {
//判断是否超出了索引
rangeCheckForAdd(index);
//判断是否需要扩容
ensureCapacityInternal(size + 1);  // Increments modCount!!
//讲elementData复制到elementData，从index开始复制，从index+1开始粘贴，复制的长度是size-index
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}

以及删除方法

public E remove(int index) {
//判断是否超出索引
rangeCheck(index);
modCount++;
E oldValue = 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;
}

3、如何复制某个ArrayList到另一个ArrayList中去？写出你的代码？

下面就是把某个ArrayList复制到另一个ArrayList中去的几种技术：

使用clone()方法，比如ArrayList newArray = oldArray.clone()

使用ArrayList构造方法，比如：ArrayList myObject = new ArrayList(myTempObject)

其他

public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}

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

综上所述，最终的复制方式都是调用Arrays.copyOf，而Arrays.copyOf是调用System.arrayscopy

public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}

4、在索引中ArrayList的增加或者删除某个对象的运行过程？效率很低吗？

这个问题同2，因为添加删除某个索引的数据时，需要整体移动数组，所以效率比较低。
5、Interator在ArrayList的实现

因为这个实现的代码比较简单这里就不多解释了，特别说明下forEachRemaining，这个方法是jdk1.8加上的，支持lamdba表达式，主要是遍历游标后面的数据，看while循环i++

private class Itr implements Iterator<E> {
int cursor;       // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
//游标的位置加1
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

参考
http://calvin1978.blogcn.com/articles/collection.html/
http://www.importnew.com/9928.html/