java源码(1):ArrayList
ArrayList是实现了List接口的一个动态可调节大小的数组可用来存放各种形式的数据，好处：1.动态的增删数据；2.数组的大小动态控制，实现了ICollection和IList接口，看源码：
继承于AbstractList抽象类，但其内部只有一个抽象方法 get()，关于AbstracktList链接: AbstractList详解
实现接口List，RandomAccess，Cloneable，java.io.Serializable。list不用解释，关于RandomAccess 是一个标记接口，用于标明实现该接口的List支持快速随机访问，详细链接:RandomAccess解释
Cloneable重写了Object的clone方法；后面的Java.io.Serializable用来对对象进行序列化，假若某个对象要在网络上传输
或者要把对象写入文件或从文件读出，那么这个对象就必须实现java.io.Serializable。
再往下走：
看几个重要的属性：
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 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.
*//百度翻译
*
*数组缓冲区，其中存储了arraylist的元素。arraylist的容量是这个数组缓冲区的长度。添加第一个元
*素时，elementdata==default capacity_empty_elementdata的任何空arraylist都将扩展为默认的
*_capacity。
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
*ArrayList的大小
* @serial
*/
private int size;初始化大小为10，elementData是存放内容的数组，size表示大小，我们常用的arrayList.size();方法下面就是return size;返回这个值。
再往下初始化方法:
//方法带默认值大小
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//构造方法传入的collection
public ArrayList(Collection c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
有三个构造方法，因为默认的值是10，这里如果没有设置默认值就不设置，如果有则去设置默认值。
再往下
//这个方法就是将arrayList中elementData的大小设置为和当前arrayList中数据的大小相等
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
变量modCount，用于记录对象的修改次数，比如增、删、改，也基本存在于非线程安全的集合类中。
//确保arrayList的容量可以支撑大小为minCapacity
//如果不能支撑，则调用ensureExplicitCapacity来进行让
//Arraylist可以支撑的起它。
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//给modcount++表示更改了数组大小
//然后调用grow来增长。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//grow方法增长了1.5倍在原来的基础上，
//调用Arrays.copyof方法来增长elementData,
//然后再看Arrays.copyof
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);
}
//
public static T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static T[] copyOf(U[] original, int newLength, Class 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;
}
//System.arraycopy是一个native方法
再继续往下看源码：
//这个方法是检查有没有这个元素的调用的是indexof
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//这个方法是返回对象o的下标，没有返回-1
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;
}
//
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;
}可以看出这个indexOf和lastindexOf方法的时间复杂度是n
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);
}
}太多了，先列几个常用方法吧：
//获取位置于index上的元素
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
这个elementData方法加了一个注解：@suppressWarnings("unchecked")， @SuppressWarnings("unchecked") 告诉编译器忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。刚查的，你看看这源码看起来还是有点味道的。
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}set方法有返回值，返回的是旧的该位置的值。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}add方法采用 ensureCapacityInternal方法来进行扩容，这个方法上面写了，你看这个方法加了两个感叹号，源码里的注解加的哦。
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;
}
这个remove方法删除index后会将后面的往前移动，然后大小减一，就不如linkedList方法好用。
好了，差不多到这了，然后重点就是arrayList扩容的时候，进行了newSize = oldSize+（oldSize >> 1）；这样的骚操作，以及它调用了。