java集合深入分析一(ArrayList)

最新推荐文章于 2024-08-22 16:13:15 发布

该昵称也已被占用了

最新推荐文章于 2024-08-22 16:13:15 发布

阅读量389

点赞数

本文详细解析了ArrayList的内部结构、构造函数、长度扩展机制、remove方法、迭代器同步机制及序列化支持等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一 ArrayList 类继承结构图

二所有属性及方法

三总体描述

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）

四数据结构

ArrayList里存放的数据结构是数组：

private transient Object[] elementData; //transient关键字作用请见另一篇博文

五源码分析

1 构造函数：3个

    public ArrayList(int initialCapacity) {
		super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
		this.elementData = new Object[initialCapacity];
    }
	
	public ArrayList() {
		this(10);
    }
	
	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);
    }

由上可知 new ArrayList(); 默认数组长度为10。

2 长度扩展机制

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

每次扩容后的长度为 (oldCapacity * 3)/2 + 1;
3 remove()方法

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

RangeCheck()的作用是进行边界检查。由于ArrayList采用一个对象数组存储元素，所以在删除一个元素时需要把后面的元素前移。删除一个元素时只是把该元素在elementData数组中的引用置为null，具体的对象的销毁由垃圾收集器负责。
modCount的作用将在下面的“iterator()中的同步”中说明。
注：在前移时使用了System提供的一个实用方法：arraycopy()，在本例中可以看出System.arraycopy()方法可以对同一个数组进行操作，这个方法是一个native方法，如果对同一个数组进行操作时，会首先把从源部分拷贝到一个临时数组，在把临时数组的元素拷贝到目标位置。

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<E> 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 E next() {
checkForComodification();
try {
E next = get(cursor);
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 void writeObject(java.io.ObjectOutputStream s)
		throws java.io.IOException{
		// Write out element count, and any hidden stuff
		int expectedModCount = modCount;
		s.defaultWriteObject();
		// Write out array length
		s.writeInt(elementData.length);
		// Write out all elements in the proper order.
		for (int i=0; i<size; i++)
		s.writeObject(elementData[i]);
		if (modCount != expectedModCount) {
		throw new ConcurrentModificationException();
		}
	}

这样元素数组elementData中的所以元素对象就可以正确地序列化到存储介质了。
对应的readObject()也按照writeObject()方法的顺序从输入流中读取：

	private 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();
		Object[] a = elementData = new Object[arrayLength];
		// Read in all elements in the proper order.
		for (int i=0; i<size; i++)
		a[i] = s.readObject();
	}

设置成transinet防止直接序列化还有一种解释是：ArrayList是会开辟多余空间来保存数据的，而系列化和反序列化这些没有存放数据的空间是要消耗更多资源的，所以ArrayList的数组就声明为transient，自己实现write/readObject方法，仅仅系列化已经存放的数据。

找时间要测试下具体哪种说法是正确的？