java.util.ArrayList

1. 类定义

//继承了AbstractList类，并且实现了List,RandomAccess,Cloneable和java.io.Serializable接口public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,java.io.Serializable  

1. 域

//默认容量为10private static final int DEFAULT_CAPACITY=10;//一个空的数组实例，用来构造空实例private static final Object[] EMPTY_ELEMENTDATA={};//ArrayList的存储数组，如果是空ArrayList，则elementData==EMPTY_ELEMENTDATAprivate transient Object[] elementData;//元素个数private int size;//数组的最大存储元素个数    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

1. 构造方法

//初始化一个容量为initialCapacity的ArrayListpublic ArrayList(int initialCapacity){  super();  if(initialCapacity<0)   throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);  this.elementData=new Object[initialCapacity];                  }//构造一个ArrayList实例，存储数组是空的public ArrayList() {        super();        this.elementData = EMPTY_ELEMENTDATA;    }//用一个集合构造一个ArrayList实例public ArrayList(Collection <? extends E> c){ elementData = c.toArray(); size=elementData.length; if(elementData.getClass!=Object[].class){  elementData=Arrays.copayOf(elementData,size,Object[].class); }}

1. 其他方法

//删除ArrayList多余的存储空间（让存储能力刚好等于存储的元素个数）public void trimToSize(){modCount++;if(size < elementData.length){ elementData = Arrays.copyOf(elmentData,size);}}//确保ArrayList的最小容量，使得能存储所有元素public ensureCapacity(int minCapacity){ int minExpand=(elementData!=EMPTY_ELEMENTDATA)?0:DEFAULT_CAPACITY; if(minCapacity>minExpand)  ensureExplicitCapactiy(minCapacity);} private void ensureCapacityInternal(int minCapacity) {        if (elementData == EMPTY_ELEMENTDATA) {            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        ensureExplicitCapacity(minCapacity);    }//如果minCapacity大于数组容量，则将数组扩充到minCapacity private void ensureExplicitCapacity(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }//ArrayList容量真正扩充是在这个方法里,正常情况下扩充为原数组长度的3/2倍。如果新的长度还是小于minCapacity则，扩充到minCapacity。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);    }//如果最小容量大于最大数组元素个数，则返回最大整数，否则返回最大数组元素个数 private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;    }//返回ArrayList的元素个数  public int size() {        return size;    }  //判断ArrayList是否为空 public boolean isEmpty() {        return size == 0;    }  //是否包含o  public boolean contains(Object o) {        return indexOf(o) >= 0;    }  //返回元素o所在位置，从数组头开始遍历，遇到第一个立即返回。给出的o可能为空，所以不能全部用o.equasl，所以要根据o是否为空选择比较方法是==还是用equals,如果没有找到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;    }//返回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(elementData[i].equals(o))return i;}return -1;}public Object clone() {        try {            @SuppressWarnings("unchecked")                ArrayList<E> v = (ArrayList<E>) 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();        }    }//返回ArryList的数组形式,返回的数组是一个新的数组，元素包含ArrayList的所有元素，但不是ArrayList本身数组的引用。即两个数组没有任何关系public Object[] toArray(){ return Arrays.copyOf(elementData,size);}//返回一个具体类型的包含ArrayList所有元素的数组public <T> T[] toArray(T[] a) {        if (a.length < size)            // Make a new array of a's runtime type, but my contents:            return (T[]) Arrays.copyOf(elementData, size, a.getClass());        System.arraycopy(elementData, 0, a, 0, size);        if (a.length > size)            a[size] = null;        return a;    }//返回数组具体位置的元素个数E elementData(int index) {        return (E) elementData[index];    } //返回具体位置的元素个数，在返回前先要对输入 的index做合法性判断public E get(int index) {        rangeCheck(index);        return elementData(index);    }//替换指定位置的元素,返回替换之前的元素public E set(int index, E element){ rangeCheck(index); E oldValue = elementData[index]; elementData[index]=element; return oldValue;}//添加一个元素public boolean add(E e){ ensureCapacityInternal(size+1);  //这个方法增加了modCount!!! elementData[size++]=e; return true;}//删除指定位置的元素public E remove(int index){ rangeCheck(index);            checkForComodification();            E result = parent.remove(parentOffset + index);            this.modCount = parent.modCount;            this.size--;            return result;}