Java集合源码学习(6)_List接口的实现_ArrayList_Vector

一：ArrayList

1：继承自AbstractList,实现了List接口；

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

2：基于可变大小的数组实现的List；允许任何值，包括null；

3：与Vector完全一样，但是Vector是同步的，ArrayList不是同步的，使用时必须在外部做好同步；

下面看一下具体的代码：

有两个类变量:

    //存放元素的数组，数组的大小就是List的容量
    private transient Object[] elementData;
    //数组中实际的元素数量
    private int size;

构造方法：

    public ArrayList() {
	this(10);//默认初始容量是10
    }

扩张当前数组方法:

    public void ensureCapacity(int minCapacity) {
	modCount++;
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	    Object oldData[] = elementData;
	    <span style="color:#ff0000;">int newCapacity = (oldCapacity * 3)/2 + 1;</span>
    	    if (newCapacity < minCapacity)
		newCapacity = minCapacity;
            //copy原来数据到新的数组
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
    }

AbstractList有的方法是基于ListIterator来实现的，但是在ArrayList，可以直接实现：比如indexOf()

public int indexOf(Object o) {//知道具体的实现的数据结构，所以可以直接查找，更为高效
       if (o==null) {
           for (int i=0; i<a.length; i++)
              if (a[i]==null)
                   return i;
       } else {
           for (int i=0; i<a.length; i++)
              if (o.equals(a[i]))
                  return i;
       }
      return -1;
}

修改方法的实现：

	
	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++;
	}
	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; // Let gc do its work

		return oldValue;
	}

二：Vector

1：与ArrayList相比，每个方法都加了synchronized关键字

2：扩容的方式与ArrayList不同，扩容方法如下：

public synchronized void ensureCapacity(int minCapacity) {
		modCount++;
		ensureCapacityHelper(minCapacity);
	}
	private void ensureCapacityHelper(int minCapacity) {
		int oldCapacity = elementData.length;
		if (minCapacity > oldCapacity) {
			Object[] oldData = elementData;
			int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement) : (oldCapacity * 2);
			if (newCapacity < minCapacity) {
				newCapacity = minCapacity;
			}
			elementData = Arrays.copyOf(elementData, newCapacity);
		}
	}

三：Stack类

Stack类继承了Vector类，增加了几个方法peek()、pop()、push()，实现了LIFO的栈；增加的这几个方法都是synchronized的；

但是，Deque这个接口和实现类更好的实现了LIFO的栈，应该优先使用；