arraylist是list接口的一个可变长数组实现。实现了所有list接口的操作，并允许存储null值。除了没有进行同步，arraylist基本等同于vector。在vector中几乎对所有的方法都进行了同步，但arraylist仅对writeobject和readobject进行了同步，其它比如add(object)、remove(int)等都没有同步。
　　
　　1.存储
　　arraylist使用一个object的数组存储元素。
　　private transient object elementdata[];
　　arraylist实现了java.io.serializable接口，这儿的transient标示这个属性不需要自动序列化。下面会在writeobject()方法中详细讲解为什么要这样作。
　　
　　2.add和remove
　　
　　　　public boolean add(object o) {
　　　　ensurecapacity(size + 1);　// increments modcount!!
　　　　elementdata[size++] = o;
　　　　return true;
　　　　}
　　
　　注意这儿的ensurecapacity()方法，它的作用是保证elementdata数组的长度可以容纳一个新元素。在“自动变长机制”中将详细讲解。
　　　　public object remove(int index) {
　　　　rangecheck(index);
　　　　modcount++;
　　　　object oldvalue = elementdata[index];
　　　　int nummoved = size - index - 1;
　　　　if (nummoved > 0)
　　　　　　system.arraycopy(elementdata, index+1, elementdata, index,
　　　　　　　　　　 nummoved);
　　　　elementdata[--size] = null; // let gc do its work
　　　　return oldvalue;
　　　　}
　　
　　rangecheck()的作用是进行边界检查。由于arraylist采用一个对象数组存储元素，所以在删除一个元素时需要把后面的元素前移。删除一个元素时只是把该元素在elementdata数组中的引用置为null，具体的对象的销毁由垃圾收集器负责。
　　modcount的作用将在下面的“iterator()中的同步”中说明。
　　注：在前移时使用了system提供的一个实用方法：arraycopy()，在本例中可以看出system.arraycopy()方法可以对同一个数组进行操作，这个方法是一个native方法，如果对同一个数组进行操作时，会首先把从源部分拷贝到一个临时数组，在把临时数组的元素拷贝到目标位置。
　　
　　3.自动变长机制
　　在实例化一个arraylist时，你可以指定一个初始容量。这个容量就是elementdata数组的初始长度。如果你使用：
　　　　arraylist list = new arraylist();
　　
　　则使用缺省的容量：10。
　　　　public arraylist() {
　　　　this(10);
　　　　}
　　
　　arraylist提供了四种add()方法，
　　
　　public boolean add(object o)
　　
　　public void add(int index, object element)
　　
　　public boolean addall(collection c)
　　
　　public boolean addall(int index, collection c)
　　
　　在每一种add()方法中，都首先调用了一个ensurecapacity(int minicapacity)方法，这个方法保证elementdata数组的长度不小于minicapacity。arraylist的自动变长机制就是在这个方法中实现的。
　　　　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 = new object[newcapacity];
　　　　　　system.arraycopy(olddata, 0, elementdata, 0, size);
　　　　}
　　　　}
　　
　　从这个方法实现中可以看出arraylist每次扩容，都扩大到原来大小的1.5倍。
　　每种add()方法的实现都大同小异，下面给出add(object)方法的实现：
　　　　public boolean add(object o) {
　　　　ensurecapacity(size + 1);　// increments modcount!!
　　　　elementdata[size++] = o;
　　　　return true;
　　　　}
　　
　　
　　4.iterator()中的同步
　　在父类abstractlist中定义了一个int型的属性：modcount，记录了arraylist结构性变化的次数。
　　　　protected transient int modcount = 0;
　　
　　在arraylist的所有涉及结构变化的方法中都增加modcount的值，包括：add()、remove()、addall()、removerange()及clear()方法。这些方法每调用一次，modcount的值就加1。
　　注：add()及addall()方法的modcount的值是在其中调用的ensurecapacity()方法中增加的。
　　
　　abstractlist中的iterator()方法（arraylist直接继承了这个方法）使用了一个私有内部成员类itr，生成一个itr对象（iterator接口）返回：
　　　　public iterator iterator() {
　　　　return new itr();
　　　　}
　　
　　itr实现了iterator()接口，其中也定义了一个int型的属性：expectedmodcount，这个属性在itr类初始化时被赋予arraylist对象的modcount属性的值。
　　　　int expectedmodcount = modcount;
　　
　　注：内部成员类itr也是arraylist类的一个成员，它可以访问所有的abstractlist的属性和方法。理解了这一点，itr类的实现就容易理解了。
　　
　　在itr.hasnext()方法中：
　　　　public boolean hasnext() {
　　　　　　return cursor != size();
　　　　}
　　
　　调用了abstractlist的size()方法，比较当前光标位置是否越界。
　　
　　在itr.next()方法中，itr也调用了定义在abstractlist中的get(int)方法，返回当前光标处的元素：
　　　　public object next() {
　　　　　　try {
　　　　　　object next = get(cursor);
　　　　　　checkforcomodification();
　　　　　　lastret = cursor++;
　　　　　　return next;
　　　　　　} catch(indexoutofboundsexception e) {
　　　　　　checkforcomodification();
　　　　　　throw new nosuchelementexception();
　　　　　　}
　　　　}
　　
　　注意，在next()方法中调用了checkforcomodification()方法，进行对修改的同步检查：
　　　　final void checkforcomodification() {
　　　　　　if (modcount != expectedmodcount)
　　　　　　throw new concurrentmodificationexception();
　　　　}
　　
　　现在对modcount和expectedmodcount的作用应该非常清楚了。在对一个集合对象进行跌代操作的同时，并不限制对集合对象的元素进行操作，这些操作包括一些可能引起跌代错误的add()或remove()等危险操作。在abstractlist中，使用了一个简单的机制来规避这些风险。这就是modcount和expectedmodcount的作用所在。
　　
　　5.序列化支持
　　arraylist实现了java.io.serializable接口，所以arraylist对象可以序列化到持久存储介质中。arraylist的主要属性定义如下：
　　
　　private static final long serialversionuid = 8683452581122892189l;
　　
　　private transient object elementdata[];
　　
　　private int size;
　　
　　可以看出serialversionuid和size都将自动序列化到介质中，但elementdata数组对象却定义为transient了。也就是说arraylist中的所有这些元素都不会自动系列化到介质中。为什么要这样实现？因为elementdata数组中存储的“元素”其实仅是对这些元素的一个引用，并不是真正的对象，序列化一个对象的引用是毫无意义的，因为序列化是为了反序列化，当你反序列化时，这些对象的引用已经不可能指向原来的对象了。所以在这儿需要手工的对arraylist的元素进行序列化操作。这就是writeobject()的作用。
　　　　private synchronized void writeobject(java.io.objectoutputstream s)
　　　　　　throws java.io.ioexception{
　　　　// write out element count, and any hidden stuff
　　　　s.defaultwriteobject();
　　　 // write out array length
　　　　s.writeint(elementdata.length);
　　　　// write out all elements in the proper order.
　　　　for (int i=0; i　　　　　　　　s.writeobject(elementdata[i]);
　　　　}
　　
　　这样元素数组elementdata中的所以元素对象就可以正确地序列化到存储介质了。
　　对应的readobject()也按照writeobject()方法的顺序从输入流中读取：
　　　　private synchronized void readobject(java.io.objectinputstream s)
　　　　　　throws java.io.ioexception, classnotfoundexception {
　　　　// read in size, and any hidden stuff
　　　　s.defaultreadobject();
　　　　// read in array length and allocate array
　　　　int arraylength = s.readint();
　　　　elementdata = new object[arraylength];
　　　　// read in all elements in the proper order.
　　　　for (int i=0; i　　　　　　　　elementdata[i] = s.readobject();
　　　　}