数组实现 父类:AbstractList 接口:List，RandomAccess，Cloneable，Serializable 字段: //默认容量 private static final int DEFAULT_CAPACITY = 10; //空的数组,构造函数参数为0和trim中使用,构造参数给0的人绝对会被打死,每放一个元素,就要重新copy一次 private static final Object[] EMPTY_ELEMENTDATA = {}; //实际保存数组,transient,这个字段不用写入流 transient Object[] elementData //实际元素数目 private int size;

public ArrayList(int initialCapacity) {        if (initialCapacity > 0)        {            this.elementData = new Object[initialCapacity];        }         else if (initialCapacity == 0)         {          //注意初始容量为0时给的对象,EMPTY_ELEMENTDATA            this.elementData = EMPTY_ELEMENTDATA;        }         else          {            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        } } public ArrayList() {          //默认构造函数        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } public ArrayList(Collection
          c) {       //转入的集合转换为数组        elementData = c.toArray();      //改变自己的size        if ((size = elementData.length) != 0)        {           //这里有个坑,可能不能正确的返回Object[] Class对象,不能的话复制            // c.toArray might (incorrectly) not return Object[] (see 6260652)            if (elementData.getClass() != Object[].class)                elementData = Arrays.copyOf(elementData, size, Object[].class);        } else         {            // replace with empty array.            this.elementData = EMPTY_ELEMENTDATA;        }  }//截断,在原数组上移动public void trimToSize() {        modCount++;        if (size < elementData.length)        {            elementData = (size == 0)              ? EMPTY_ELEMENTDATA              : Arrays.copyOf(elementData, size);        } }//比较关心的几个方法,存放,取出,查找//查找,运行时间上界O(n),从这里也可用看出是允许放nullpublic 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;  }//反向查找 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; }//返回index位置的元素E elementData(int index) {        return (E) elementData[index]; }//获取对应位置元素,O(1) public E get(int index) {       //检查size,并没有判断小于0        rangeCheck(index);        return elementData(index);}//将元素放在对应位置,index
         
           list = new ArrayList<>(100);//		list.set(10, "123");//根据构造函数可以知道,已经开辟了100长度的数组,但是就是不让你用 public E set(int index, E element) {        rangeCheck(index);        E oldValue = elementData(index);        elementData[index] = element;        return oldValue;}private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        //原来的1.5备长度        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        elementData = Arrays.copyOf(elementData, newCapacity); } private void ensureExplicitCapacity(int minCapacity) {        modCount++;        // overflow-conscious code        //1-0,进入if,进行内存复制,开辟新的数组        if (minCapacity - elementData.length > 0)            grow(minCapacity);}private void ensureCapacityInternal(int minCapacity) {       //构造函数给0,这里是false        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)         {            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }                 //ensureExplicitCapacity(1);        ensureExplicitCapacity(minCapacity); }//增加一个元素 public boolean add(E e)  {       //为什么构造函数给0会被打死,看下面这个函数,一来就要新数组,新的数组长度也只有1        ensureCapacityInternal(size + 1);  // Increments modCount!!        elementData[size++] = e;        return true; }//元素放到index位置,0<=index
          
            0)            System.arraycopy(elementData, index+1, elementData, index,                             numMoved);        elementData[--size] = null; // clear to let GC do its work        return oldValue;}//O(n)的移除,注意在fastRemove方法里面也会出现内存复制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; }//为什么elementData不用置null,方便重用public void clear() {        modCount++;        // clear to let GC do its work        for (int i = 0; i < size; i++)            elementData[i] = null;        size = 0; }//浅克隆public Object clone() {        try {            ArrayList
            v = (ArrayList
           ) 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(e);        }  }//返回副本 public Object[] toArray() {        return Arrays.copyOf(elementData, size);}结尾附上一个内存分布的代码,有指针真好int main(int argc, char* argv[]){	//int ba[4];	int a[] = { 1, 2, 3, 4 };	int c = 5;	int d = 6;	int dd = 7;	cout << a << endl;	cout << a[-1] << endl;	cout << a-1 << endl;	cout<<&dd<