ArrayList 源码实现

 

      再看集合方面的知识

      看的是 ArrayList 的实现，在源码打断点，却没有进去，想在源码里 打log，发现不能修改。

          就写个文章 帮助理理吧。

 

1. ArrayList 实际上 是一个数组

      private transient Object[] elementData; 

2. 构造方法

      ArrayList 有三个构造方法

 

写道

// 构造一个 默认初始容量为10的空列表
public ArrayList() {
this(10);
}

//构造一个指定 初始容量的空列表
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}

//构造一个包含指定 collection 的元素的列表。
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);
}

 3. 扩充数组容量

增加前，调整数组容量 写道

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

 参考：http://zhangshixi.iteye.com/blog/674856

   

4. ArrayList中 add方法 

//在集合尾部 添加  一个集合     
public boolean addAll(Collection<? extends E> c) {
	Object[] a = c.toArray();
        int numNew = a.length;
	ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
	return numNew != 0;
    }

// 在集合的指定位置  添加一个集合
    public boolean addAll(int index, Collection<? extends E> c) {
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(
		"Index: " + index + ", Size: " + size);

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacity(size + numNew);  // Increments modCount

	int numMoved = size - index;
	if (numMoved > 0)
	    System.arraycopy(elementData, index, elementData, index + numNew,
			     numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
	size += numNew;
	return numNew != 0;
    }


//  在集合末尾添加一个元素
    public boolean add(E e) {
	ensureCapacity(size + 1);  // Increments modCount!!
	elementData[size++] = e;
	return true;
    }

// 在集合的指定位置 添加 一个元素
    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++;
    }

 5。Iterator的同步

       有一个变量 modCount，定义在父类  AbstractList中定义了一个int的属性：modCount，用来记录ArrayList结构变化的次数。

protected transient int modCount = 0;

 在ArrayList中所有涉及 结构变化的方法，都增加modCount的值，包括：add  remove  addAll   removeRange  及clear  等方法。

在 AbstractList 中，iterator()方法(ArrayList直接继承了这个方法)，使用了私有的内部成员类 Itr，生成一个 Itr对象（Iterator接口）返回。

 

    public Iterator<E> iterator() {
	return new Itr();
    }
    private class Itr implements Iterator<E> {
	/**
	 * Index of element to be returned by subsequent call to next.
	 */
	int cursor = 0;

	/**
	 * Index of element returned by most recent call to next or
	 * previous.  Reset to -1 if this element is deleted by a call
	 * to remove.
	 */
	int lastRet = -1;

	/**
	 * The modCount value that the iterator believes that the backing
	 * List should have.  If this expectation is violated, the iterator
	 * has detected concurrent modification.
	 */
	int expectedModCount = modCount;

	public boolean hasNext() {
            return cursor != size();
	}

	public E next() {
            checkForComodification();
	    try {
		E next = get(cursor);
		lastRet = cursor++;
		return next;
	    } catch (IndexOutOfBoundsException e) {
		checkForComodification();
		throw new NoSuchElementException();
	    }
	}

	public void remove() {
	    if (lastRet == -1)
		throw new IllegalStateException();
            checkForComodification();

	    try {
		AbstractList.this.remove(lastRet);
		if (lastRet < cursor)
		    cursor--;
		lastRet = -1;
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException e) {
		throw new ConcurrentModificationException();
	    }
	}

	final void checkForComodification() {
	    if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
	}
    }

 在上边代码中，也定义了一个int的属性：expectedModCount，这个属性在Itr类初始化的时候被赋予ArrayList对象的modCount属性的值。

这些有些深了，以后遇到再来看。

参考：http://javag.iteye.com/blog/278781