ArrayList的创建
默认构造函数:
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
从上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA 这个参数的的名字可以看出是默认的空的元素数据。但DEFAULTCAPACITY_EMPTY_ELEMENTDATA的数据类型是什么呢?
我们接着再看,
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
就是一个空的一维数组,不过注释中提到了default sized empty instance,那么default size 到底是多少呢?还是不知道,那么我们可以转换下看思路看能不能从类的属性中找到呢?简单点,望文生义,
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
默认是10;
那么,这算不算是把ArrayList的构造函数阅读完了呢?不算,因为还没有将DEFAULT_CAPACITY 和上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA一维空数组关联起来,接下来通过阅读另一个构造函数ArrayList(int initialCapacity),看看有什么收获?
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
这段代码很好理解:如果是initialCapacity的数值大于0,就使用initalCapacity开辟数组,如果等于0,就使用默认容量,如果为负数,就抛异常。
容量,数组中元素的个数,是什么关系?
ArrayList的添加,重点是add函数
关键问题:
1. 当数组满了时候,ArrayList是如何处理的?即扩容问题
2. 扩容的过程中使用的怎样的策略,来保证原来数组中的数据不丢失?
先解决第一个问题:
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
不好理解的是ensureCapacityInternal这个方法,但从字面上理解,就是确保容量足够,那么是怎样确保容量足够呢?如果所有的内存都占用完了呢?怎么办?这个问题也是我被腾讯面试官问到的问题,如果这个方法执行完毕,就可以正常的添加元素了,接下来就看看ensureCapacityInternal这个函数
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
最小容量等于默认容量和最小容量的最大值,那么接下来 ensureExplicitCapacity函数应该就是扩内存容量的,源码中就有grow方法。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
问题1、modCount作用?2、grow方法内部实现是怎样的?
解决问题1,看源码读注释:
/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
*
* <p>This field is used by the iterator and list iterator implementation
* returned by the {@code iterator} and {@code listIterator} methods.
* If the value of this field changes unexpectedly, the iterator (or list
* iterator) will throw a {@code ConcurrentModificationException} in
* response to the {@code next}, {@code remove}, {@code previous},
* {@code set} or {@code add} operations. This provides
* <i>fail-fast</i> behavior, rather than non-deterministic behavior in
* the face of concurrent modification during iteration.
*
* <p><b>Use of this field by subclasses is optional.</b> If a subclass
* wishes to provide fail-fast iterators (and list iterators), then it
* merely has to increment this field in its {@code add(int, E)} and
* {@code remove(int)} methods (and any other methods that it overrides
* that result in structural modifications to the list). A single call to
* {@code add(int, E)} or {@code remove(int)} must add no more than
* one to this field, or the iterators (and list iterators) will throw
* bogus {@code ConcurrentModificationExceptions}. If an implementation
* does not wish to provide fail-fast iterators, this field may be
* ignored.
*/
protected transient int modCount = 0;
关键句The number of times this list has been structurally modified.就是说明了modCount的作用是表示修改的次数。至于这个属性的详细作用可以从接下来的注释中去看。
解决问题2:
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
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 = Arrays.copyOf(elementData, newCapacity);
}
划重点:旧容量等于数组的长度,新容量为旧容量的1.5倍,因为oldCapacity>>1是0.5倍的oldCapacity,再加上原来的oldCapacity,即为1.5倍。如果新容量小于最小容量,那么新容量等于最小容量(就是取两者中的最大值)。接着看,如果新容量大于MAX_ARRAY_SIZE(最大数组容量),那么新的容量就等于hugeCapacity(minCapacity)的容量。关键问题:hugeCapacity方法的作用是?如果以上语句都执行了,就将原来的数组复制到新的容量的数组中。没说的。
解决hugeCapacity方法的作用是?
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
问题:minCapacity有没有可能小于0,报OutOfMemoryError,个人感觉不可能,因为这个minCapacity还是从add方法中来的。等于size+1;下面就是minCapacity大于MAX_ARRAY_SIZE(最大数组容量),就返回整型数据的最大值,否则就返回MAX_ARRAY_SIZE。就是说普通情况下ArrayList的最大的容量就是Integer.MAX_VALUE。这个ArrayList的峰值。
总结
本文主要梳理了ArrayList的扩容策略,简单点,就是当容量不足时,开辟一个新数组,将就数组中的元素都赋值过去。再这个过程中的,难点是开辟新数组的容量如何设置的问题。