首先
public class ArrayList<E> extends AbstractList<E> implements Cloneable, Serializable, RandomAccess
ArrayList类实现了这三个接口， 具有可复制的，可序列化的，以及快速随机访问的特性。
一， 构造函数
public ArrayList(int capacity) { // EmptyArray.OBJECT 其实就是new Object[0])；
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
array = (capacity == 0 ? EmptyArray.OBJECT : new Object[capacity]);
}
public ArrayList() {
array = EmptyArray.OBJECT;
}
public ArrayList(Collection<? extends E> collection) {
if (collection == null) {
throw new NullPointerException("collection == null");
}
Object[] a = collection.toArray();
if (a.getClass() != Object[].class) {
Object[] newArray = new Object[a.length];
System.arraycopy(a, 0, newArray, 0, a.length);
a = newArray;
}
array = a;
size = a.length;
}
add()和addAll()方法 。
1.添加add(E object)
@Override public boolean add(E object) {
Object[] a = array;
int s = size;
if (s == a.length) { //数组里刚好放满。（有可能 不相等， 有剩余容量 。a.length 有可能 大于size.）
Object[] newArray = new Object[s + //MIN_CAPACITY_INCREMENT = 12;
(s < (MIN_CAPACITY_INCREMENT / 2) ? // 如果原数组个数少于6个,扩容增加12个， 否则，容量增加当前容量的一半。
MIN_CAPACITY_INCREMENT : s >> 1)];
System.arraycopy(a, 0, newArray, 0, s);
array = a = newArray; // 替换为新数组。
}
a[s] = object; // 最后设置为刚添加的数
size = s + 1;
modCount++;
return true;
}
2 .add(int index, E object) 指定添加位置
@Override public void add(int index, E object) {
Object[] a = array;
int s = size;
if (index > s || index < 0) {
throwIndexOutOfBoundsException(index, s);
}
if (s < a.length) { // 数组中有末用空间，直接添加这个数
System.arraycopy(a, index, a, index + 1, s - index);//数组在指定位置 全部后移，
} else {
// assert s == a.length;
Object[] newArray = new Object[newCapacity(s)]; // newCapacity 扩容。
System.arraycopy(a, 0, newArray, 0, index); //拷贝到新数据newArray里
System.arraycopy(a, index, newArray, index + 1, s - index); // /数组在指定位置 全部后移，
array = a = newArray; // 设置为当前数组
}
a[index] = object; // 在指定位置插入值
size = s + 1;
modCount++;
}
3,addAll(Collection<? extends E> collection)添加集合
@Override public boolean addAll(Collection<? extends E> collection) {
Object[] newPart = collection.toArray();
int newPartSize = newPart.length;
if (newPartSize == 0) {
return false;
}
Object[] a = array;
int s = size;
int newSize = s + newPartSize; // If add overflows, arraycopy will fail
if (newSize > a.length) {
int newCapacity = newCapacity(newSize - 1); // ~33% growth room
Object[] newArray = new Object[newCapacity];
System.arraycopy(a, 0, newArray, 0, s);
array = a = newArray;
}
System.arraycopy(newPart, 0, a, s, newPartSize);
size = newSize;
modCount++;
return true;
}
4.addAll(int index, Collection<? extends E> collection)指定位置添加集合
@Override
public boolean addAll(int index, Collection<? extends E> collection) {
int s = size;
if (index > s || index < 0) {
throwIndexOutOfBoundsException(index, s);
}
Object[] newPart = collection.toArray();
int newPartSize = newPart.length;
if (newPartSize == 0) {
return false;
}
Object[] a = array;
int newSize = s + newPartSize; // If add overflows, arraycopy will fail
if (newSize <= a.length) { // 当前数组容量够用， 直接拷贝
System.arraycopy(a, index, a, index + newPartSize, s - index);
} else {
int newCapacity = newCapacity(newSize - 1); // ~33% growth room
Object[] newArray = new Object[newCapacity];
System.arraycopy(a, 0, newArray, 0, index);
System.arraycopy(a, index, newArray, index + newPartSize, s-index);
array = a = newArray;
}
System.arraycopy(newPart, 0, a, index, newPartSize);
size = newSize;
modCount++;
return true;
}
前面都用到了这个关键的方法，理解了这个函数， 上面的大家都能看懂
* @param src
* 源数据 ， 一个数组
* @param srcPos
* 源数据开始的拷贝位置
* @param dst
* 目标数组
* @param dstPos
* 目标数据开始的放置位置 。
* @param length
* 拷贝长度 。
*/
public static native void arraycopy(Object src, int srcPos,
Object dst, int dstPos, int length);
其它的方法都比较简单，大家可以自行看源码。
总结下：
1.ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低
2.ArrayList不是线程安全的。
3.ArrayList中允许元素为null。
