public class ArrayList<E> extends AbstractList<E>  implements List<E>, RandomAccess, Cloneable, java.io.Serializable  

（1）AbstractList提供了List接口的默认实现（个别方法为抽象方法）。

（2）RandomAccess是一个标记接口，接口内没有定义任何内容。

（3）实现了Cloneable接口的类，可以调用Object.clone方法返回该对象的浅拷贝。

（4） 通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。序列化接口没有方法或字段，仅用于标识可序列化的语义。

二、---属性---

/*The array buffer into which the elements of the ArrayList are stored. 
      * The capacity of the ArrayList is the length of this array buffer. 
      */  
     private transient Object[] elementData;  
     /** 
      * The size of the ArrayList (the number of elements it contains). 
      */  
     private int size; 

通过例子来说明一下：

package TwoWeek;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class UserInfo implements Serializable {  
    private static final long serialVersionUID = 996890129747019948L;  
    private String name;  
    private transient String psw;  
  
    public UserInfo(String name, String psw) {  
        this.name = name;  
        this.psw = psw;  
    }  
  
    public String toString() {  
        return "name=" + name + ", psw=" + psw;  
    }  
}  
  
public class TestTransient {  
    public static void main(String[] args) {  
        UserInfo userInfo = new UserInfo("张三", "123456");  
        System.out.println(userInfo);  
        try {  
            // 序列化，被设置为transient的属性没有被序列化  
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(  
                    "UserInfo.out"));  
            o.writeObject(userInfo);  
            o.close();  
        } catch (Exception e) {  
            // TODO: handle exception  
            e.printStackTrace();  
        }  
        try {  
            // 重新读取内容  
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(  
                    "UserInfo.out"));  
            UserInfo readUserInfo = (UserInfo) in.readObject();  
            //读取后psw的内容为null  
            System.out.println(readUserInfo.toString());  
        } catch (Exception e) {  
            // TODO: handle exception  
            e.printStackTrace();  
        }  
    }  
}  

name=张三, psw=123456
name=张三, psw=null

三、---构造方法---

/** 
      * Constructs an empty list with the specified initial capacity. 
      */  
     public ArrayList(int initialCapacity) {  
     super();  
         if (initialCapacity < 0)  
             throw new IllegalArgumentException("Illegal Capacity: "+  
                                                initialCapacity);  
     this.elementData = new Object[initialCapacity];  
     }  
     /** 
      * Constructs an empty list with an initial capacity of ten. 
      */  
     public ArrayList() {  
     this(10);  
     }    
     /** 
      * Constructs a list containing the elements of the specified 
      * collection, in the order they are returned by the collection's 
      * iterator. 
      */  
     public ArrayList(Collection<? extends E> c) {  
     elementData = c.toArray();  
     size = elementData.length;  
     // c.toArray might (incorrectly) not return Object[] (see 6260652)  
     if (elementData.getClass() != Object[].class)  
         elementData = Arrays.copyOf(elementData, size, Object[].class);  
     }  

public boolean add(E e) {  
    ensureCapacity(size + 1);  // Increments modCount!!  
    elementData[size++] = e;  
    return true;  
    }  

     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;  
             // minCapacity is usually close to size, so this is a win:  
             elementData = Arrays.copyOf(elementData, newCapacity);  
     }  
     } 

public void add(int index, E element) {  
     if (index > size || index < 0)  
         throw new IndexOutOfBoundsException(  
         "Index: "+index+", Size: "+size);  
   
     ensureCapacity(size+1);  // Increments modCount!!  
     System.arraycopy(elementData, index, elementData, index + 1,  
              size - index);  
     elementData[index] = element;  
     size++;  
     }  

4.3 contains(Object)

public boolean contains(Object o) {  
     return indexOf(o) >= 0;  
     }  

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;  
     }  

4.4 removeRange

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;  
     } 

public class LinkedList<E>  
    extends AbstractSequentialList<E>  
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable  

private transient Entry<E> header = new Entry<E>(null, null, null);  
private transient int size = 0;  

private static class Entry<E> {  
        E element;        //元素节点  
        Entry<E> next;    //下一个元素  
        Entry<E> previous;  //上一个元素  
        Entry(E element, Entry<E> next, Entry<E> previous) {  
            this.element = element;  
            this.next = next;  
            this.previous = previous;  
        }  
    }  

三、---构造方法---

/** 
     *  构造一个空列表。 
     */  
    public LinkedList() {  
        header.next = header.previous = header;  
    }  
    /** 
     *  构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。 
     */  
    public LinkedList(Collection<? extends E> c) {  
        this();  
        addAll(c);  
    }

四、---其他方法---

/** 
     *  添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。 
     */  
    public boolean addAll(Collection<? extends E> c) {  
        return addAll(size, c);  
    }     
    /** 
     * 将指定 collection 中的所有元素从指定位置开始插入此列表。其中index表示在其中插入指定collection中第一个元素的索引 
     */  
    public boolean addAll(int index, Collection<? extends E> c) {  
        //若插入的位置小于0或者大于链表长度，则抛出IndexOutOfBoundsException异常  
        if (index < 0 || index > size)  
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);  
        Object[] a = c.toArray();  
        int numNew = a.length;    //插入元素的个数  
        //若插入的元素为空，则返回false  
        if (numNew == 0)  
            return false;  
        //modCount:在AbstractList中定义的，表示从结构上修改列表的次数  
        modCount++;  
        //获取插入位置的节点，若插入的位置在size处，则是头节点，否则获取index位置处的节点  
        Entry<E> successor = (index == size ? header : entry(index));  
        //插入位置的前一个节点，在插入过程中需要修改该节点的next引用：指向插入的节点元素  
        Entry<E> predecessor = successor.previous;  
        //执行插入动作  
        for (int i = 0; i < numNew; i++) {  
            //构造一个节点e，这里已经执行了插入节点动作同时修改了相邻节点的指向引用  
            Entry<E> e = new Entry<E>((E) a[i], successor, predecessor);  
            //将插入位置前一个节点的下一个元素引用指向当前元素  
            predecessor.next = e;  
            //修改插入位置的前一个节点，这样做的目的是将插入位置右移一位，保证后续的元素是插在该元素的后面，确保这些元素的顺序  
            predecessor = e;  
        }  
        successor.previous = predecessor;  
        //修改容量大小  
        size += numNew;  
        return true;  
    }  

/** 
     * 返回指定位置(若存在)的节点元素 
     */  
    private Entry<E> entry(int index) {  
        if (index < 0 || index >= size)  
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "  
                    + size);  
        //头部节点  
        Entry<E> e = header;  
        //判断遍历的方向  
        if (index < (size >> 1)) {  
            for (int i = 0; i <= index; i++)  
                e = e.next;  
        } else {  
            for (int i = size; i > index; i--)  
                e = e.previous;  
        }  
        return e;  
    }  

4.2 add( E e )

public boolean add(E e) {  
    addBefore(e, header);  
        return true;  
    }  

private Entry<E> addBefore(E e, Entry<E> entry) {  
        //利用Entry构造函数构建一个新节点 newEntry，  
        Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);  
        //修改newEntry的前后节点的引用，确保其链表的引用关系是正确的  
        newEntry.previous.next = newEntry;  
        newEntry.next.previous = newEntry;  
        //容量+1  
        size++;  
        //修改次数+1  
        modCount++;  
        return newEntry;  
    } 

public boolean remove(Object o) {  
        if (o==null) {  
            for (Entry<E> e = header.next; e != header; e = e.next) {  
                if (e.element==null) {  
                    remove(e);  
                    return true;  
                }  
            }  
        } else {  
            for (Entry<E> e = header.next; e != header; e = e.next) {  
                if (o.equals(e.element)) {  
                    remove(e);  
                    return true;  
                }  
            }  
        }  
        return false;  
    }  

private E remove(Entry<E> e) {  
        if (e == header)  
            throw new NoSuchElementException();  
  
        //保留被移除的元素：要返回  
        E result = e.element;    
        //将该节点的前一节点的next指向该节点后节点  
        e.previous.next = e.next;  
        //将该节点的后一节点的previous指向该节点的前节点  
        //这两步就可以将该节点从链表从除去：在该链表中是无法遍历到该节点的  
        e.next.previous = e.previous;  
        //将该节点归空  
        e.next = e.previous = null;  
        e.element = null;  
        size--;  
        modCount++;  
        return result;  
    }