java ArrayList 源码 解析

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;

/**
*
*
内部结构是一个Object类型的数组
       成员变量,用来保存数据

*/
private transient Object[] elementData;

/**
*
* 元素的个数。 不是 elementData.length。而是 arraylist.size()
*
*/
private int size;

/**
*
构造器初始化
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); //初始化容量不能小于0,抛出IllegalArgumentException异常
this.elementData = new Object[initialCapacity];//根据参数初始化一个数组,底层是个object数组
}

/**
*
　　　 构造器 初始化 默认lenght 为10　
*/
public ArrayList() {
　　this(10);//默认初始容量是10
}

/**
* */
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();//调用toArray()方法把collection转换成数组
size = elementData.length;//把数组的长度赋值给ArrayList的size属性
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}

/**
* 重新分配ArrayList空间为元素多少的真实大小
*/
public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}

/**
*  数组长度自增长。如果不够则扩展一半加1*/
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

/**
* 数据长度*/
public int size() {
return size;
}

/**
* 是否为空*/
public boolean isEmpty() {
return size == 0;
}

/**
* 是否包含某个值*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}

/**
找到数组中第一个相等的值。如果不存在返回-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;
}

/**
 找到数组中最后一个相等的值。如果不存在返回-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;
}

/**       clone一个副本
*/
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {

throw new InternalError();
}
}

/**

*  转数组
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}

/**
转换为泛型数组*/
public <T> T[] toArray(T[] a) {
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);//把elementData从索引0开始的size个值 复制到a数组索引为0的位置上
if (a.length > size)
a[size] = null;
return a;
}

/**
* 获得第几个对应的值从0开始
*/
public E get(int index) {
RangeCheck(index);//先检查是否越界

return (E) elementData[index];
}

/**
*  修改对应序号上的值*/
public E set(int index, E element) {
RangeCheck(index);//先检查是否越界

E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}

/**
* 添加值
    */
public boolean add(E e) {
ensureCapacity(size + 1);  //确保长度够大
elementData[size++] = e;
return true;
}

/**
* 在摸个位置插入某值*/
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);

ensureCapacity(size+1);
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}

API文档中的说明是:将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。通俗的说法是在指定位置插入元素，指定元素和后面的元素后移。这个方法和set(int index, E element) 不一样,set只是把元素赋值给指定的下标同时返回下标的原先值. set(int index, E element)的判断越界是通过元素的大小来判断的（RangeCheck(index)）。add 是 if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); 判断是否越界。

/**
*  删除某个位置上的值*/
public E remove(int index) {
RangeCheck(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;

return oldValue;
}

/**
* 删除值*/
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 void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}

/**
清空所有值
*/
public void clear() {
modCount++;

// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;

size = 0;
}

/**
* 添加 集合*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew);
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}

/**
* 在某个位置插入集合*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);

Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(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;
}

/**
* 删除从一定范围内的数据*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);

// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}

/**
是否超出数组长度
*/
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}

/***/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{

int expectedModCount = modCount;
s.defaultWriteObject();

s.writeInt(elementData.length);

for (int i=0; i<size; i++)
s.writeObject(elementData[i]);

if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}

}

private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {

s.defaultReadObject();

int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];

for (int i=0; i<size; i++)
a[i] = s.readObject();
}
}

Arrays.copyOf 方法：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {

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;

}

　　arraycopy 方法会因为新数组大小比旧数组大小小而报IndexOutOfBoundsException

　　copyOf 则不会因此报错，因为copyOf 的返回值是在内部new 好的copy 数组，而该copy 数组new 的大小就等于newLength ，

　　故即使在客户端指定好了新数组newArray 的大小，接收到返回值后也是指向底层new 出来的数组copy 。换句话说( 也可以因此推出其他的区别) ，在客户端代码中即使不给新数组new 对象，如：String[] newStr = null;

那么对于arraycopy 是会报NullPointerException 的错误的，而对于java.util.Arrays 中的copyOf 方法则由于jdk 底层

已经new 出了对象而不会报该错误！不过需要特别注意的是：copyOf 方法最后也是调用System.arraycopy 的方法，不过由于前面的准备，异常情况就不会出现了。