ArrayList概述
下文用昵称“小A”表示ArrayList的一个实例:)
ArrayList是一个实现了List接口的大小可变的数组，可类比于Vector，但是ArrayList是unsynchronized(非同步的)，而Vector类是synchronized(同步的)。获取ArrayList信息的一些方法比如size()、isEmpty()、get()、set()、iterator()、listIterator()运行的时间复杂度是O(1)，即常数时间。add()操作在摊还分析下运行的时间复杂度也是O(1)(关于摊还分析可参考《算法导论》第三版第17章“摊还分析”里的内容)，一般而言我们添加n个元素到小A中的时间复杂度是O(n)。剩下的其他操作运行的时间复杂度是O(n)。
小A有属性capacity代表小A存储元素用到的空间大小。当然单位不是字节，而是元素的个数。小A还有一个属性size表示小A实际拥有的元素数量，而总是有capacity>=size。实际上capacity表示的就是小A能装多少元素的能力，而size则是已经装了多少，就像龙夫山泉矿泉水瓶最多能装capacity为600ml水，而现在只有size为300ml的水在瓶子里面。在向小A中添加元素的时候，capacity会自动增长。在向小A中添加大量元素之前，我们可以使用ensureCapacity()操作提升小A的capacity值，以避免小A扩容时大量的内存空间再分配。
最后，ArrayList可是JAVA Collections Framework的成员。
ArrayList源码分析
ArrayList扩展了AbstractList，实现了接口List、RandomAccess、Cloneable、java.io.Serializable。但是我们不分析其继承的一些特性，只分析我们常用而由容易忽略的内容。
ArrayList定义了一个默认的初始容量:
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;其内部声明了一个数组：
transient Object[] elementData;定义了size表示其拥有的元素数量：
/**
* The size of the ArrayList (the number of elements it contains).
* @serial
*/
private int size;
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};接下来我们分析最长用到的两个构造函数：
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {// 如果外部设定的容量大于0，则分配指定容量的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {// 如果传入的容量为0,则让elementData指向EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
} else {// 传入的容量为负数，则抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}接下来我们分析trimToSize():
public void trimToSize() {
modCount++;// 修改操作计数加
if (size < elementData.length) {// 当然只有size小于才会执行接下来的操作
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}我们再分析ensureCapacity(int mincapacity):
public void ensureCapacity(int minCapacity) {
if (minCapacity > elementData.length
&& !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
&& minCapacity <= DEFAULT_CAPACITY)) {
modCount++;
grow(minCapacity);
}
}
private Object[] grow(int minCapacity) {
return elementData = Arrays.copyOf(elementData,
newCapacity(minCapacity));
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE)
? Integer.MAX_VALUE
: MAX_ARRAY_SIZE;
}接下来我们分析contains(Object o):
public boolean contains(Object o) {
return indexOf(o) >= 0;
}我们看indexOf(Object o)函数:
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}我再看和indexOf(Object)相似的函数lastIndexOf(Object o):
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}我们再看get(int)函数:
/**
* 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) {
Objects.checkIndex(index, size);
return elementData(index);
}我们再看set(int, element)函数:
/**
* 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) {
Objects.checkIndex(index, size);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}我们再看add()函数:
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
public void add(int index, E element) {
rangeCheckForAdd(index);
modCount++;
final int s;
Object[] elementData;
if ((s = size) == (elementData = this.elementData).length)
elementData = grow();
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
}这三个add()函数都是类似的，基本思路就是添加元素的时候判断当前容量是否足够，如果不足够则分配新的内存空间。
然后我们看下几个移除函数的源码：
/**
* Removes the element at the specified position in this list.
* Shifts any subsequent elements to the left (subtracts one from their
* indices).
*
* @param index the index of the element to be removed
* @return the element that was removed from the list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E remove(int index) {
Objects.checkIndex(index, size);
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;
}
/**
* Removes the first occurrence of the specified element from this list,
* if it is present. If the list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index
* {@code i} such that
* {@code Objects.equals(o, get(i))}
* (if such an element exists). Returns {@code true} if this list
* contained the specified element (or equivalently, if this list
* changed as a result of the call).
*
* @param o element to be removed from this list, if present
* @return {@code true} if this list contained the specified element
*/
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
/**
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
modCount++;
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
}然后看remove(Object o)，这个函数首先需要根据传入的对象在数组中知道其首次出现的位置，如果找到的话就调用fastRemove(int index)将其移除，其实fastRemove(int index)和remove(int index)是一样的，只不过少了边界检查且并不返回被移除的值，毕竟这是内部的一个私有函数。
最后我们看clear()函数：
**
* Removes all of the elements from this list. The list will
* be empty after this call returns.
*/
public void clear() {
modCount++;
final Object[] es = elementData;
for (int to = size, i = size = 0; i < to; i++)
es[i] = null;
}ArrayList的源码就简单地分析到此。
248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
