Java中的ArrayList的初始容量和容量分配
List接⼝的⼤⼩可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。
ArrayList继承于List接⼝，除继承过来的⽅法外，还提供⼀些⽅法来操作内部⽤来存储列表的数组的⼤⼩。
每个ArrayList实例都有⼀个容量。该容量是指⽤来存储列表元素的数组的⼤⼩。它总是⾄少等于列表的⼤⼩。随着向ArrayList中不断添加元素，其容量也⾃动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
ArrayList是经常会被⽤到的，⼀般情况下，使⽤的时候会像这样进⾏声明：
List arrayList = new ArrayList();
如果像上⾯这样使⽤默认的构造⽅法，初始容量被设置为10。当ArrayList中的元素超过10个以后，会重新分配内存空间，使数组的⼤⼩增长到16。
可以通过调试看到动态增长的数量变化：10->16->25->38->58->88->...
也可以使⽤下⾯的⽅式进⾏声明：
List arrayList = new ArrayList(4);
将ArrayList的默认容量设置为4。当ArrayList中的元素超过4个以后，会重新分配内存空间，使数组的⼤⼩增长到7。
可以通过调试看到动态增长的数量变化：4->7->11->17->26->...
那么容量变化的规则是什么呢？请看下⾯的公式：
((旧容量 * 3) / 2) + 1
注：这点与C#语⾔是不同的，C#当中的算法很简单，是翻倍。
⼀旦容量发⽣变化，就要带来额外的内存开销，和时间上的开销。
所以，在已经知道容量⼤⼩的情况下，推荐使⽤下⾯⽅式进⾏声明：
List arrayList = new ArrayList(CAPACITY_SIZE);
即指定默认容量⼤⼩的⽅式。
java arraylist用法
探索ArrayList⾃动改变size真相
ArrayList的列表对象实质上是存储在⼀个引⽤型数组⾥的，有⼈认为该数组有“⾃动增长机制”可以⾃动改变size⼤⼩。正式地说，该数组是⽆法改变
⼤⼩的，实际上它只是改变了该引⽤型数组的指向⽽已。下⾯，让我们来看看java是怎样实现ArrayList类的。
⼀、ArrayList类的实质
ArrayList底层采⽤Object类型的数组实现，当使⽤不带参数的构造⽅法⽣成ArrayList对象时，
实际上会在底层⽣成⼀个长度为10的Object类型数组。
⾸先，ArrayList定义了⼀个私有的未被序列化的数组elementData，⽤来存储ArrayList的对象列表（注意只定义未初始）：
  private transient Object[] elementData;
其次，以指定初始容量（Capacity）或把指定的Collection转换为引⽤型数组后实例化elementData数组；如果没有指定，则预置初始容量为10进⾏
实例化。把私有数组预先实例化，然后通过copyOf⽅法覆盖原数组，是实现⾃动改变ArrayList的⼤⼩(size)的关键。有⼈说ArrayList是复杂的数组，我
认为不如说ArrayList是关于数组的系统的⽅法组合。
  ArrayList的构造⽅法源码如下：
// ⽤指定的初始容量构造⼀个空列表。
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
this.elementData = new Object[initialCapacity];//属性指向新建长度为初始容量的临时数组
}
// 使⽤初始容量10构造⼀个空列表
public ArrayList() {
this(10);
}
/ *构造包含利⽤collection的迭代器按顺序返回的指定collection元素的列表
* @param c 集合，它的元素被⽤来放⼊列表t
* @throws NullPointerException 如果指定集合为null
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();//⽤Collection初始化数组elementData
size = elementData.length;
if (Class() != Object[].class)
elementData = pyOf(elementData, size, Object[].class);
}
⼆、ArrayList实现⾃动改变size机制
为了实现这⼀机制，java引进了Capacity和size概念，以区别数组的length。为了保证⽤户增加新的列表对象，java设置了最⼩容量（minCapacity）
，通常情况上，它⼤于列表对象的数⽬，所以Capactiy虽然就是底层数组的长度（length），但是对于最终⽤户来讲，它是⽆意义的。⽽size存储着列表
对象的数量，才是最终⽤户所需要的。为了防⽌⽤户错误修改，这⼀属性被设置为privae的，不过可以通过size()获取。
下⾯，对ArrayList的初始以及其列表对象的增加和删除等三种情况下的size⾃动改变机制进⾏分析。
1、初始Capacity和size值。
从上⾯给出的ArrayList构造⽅法源码中，我们不难看出Capacity初始值（initialCapacity）可以由⽤户直接指定或由⽤户指定的Collection集合存
储的对象数⽬确定，如果没有指定，系统默认为10。⽽size的被声明为int型变量，默认为0，当⽤户指定Collection创建ArrayList时，size值等于initialCapacity。
2、add()⽅法
该⽅法的源码如下：
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;//添加对象时，⾃增size
return true;
}
⽅法中调⽤的ensureCapacityInternal主要⽤来调整容量，修改elementData数组的指向。其中涉及到3个⽅法的调⽤，其核⼼在于grow⽅法：private void ensureCapacityInternal(int minCapacity) {
modCount++;//定义于ArrayList的⽗类AbstractList，⽤于存储结构修改次数
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量扩⼤到原容量的1.5倍，右移⼀位相关于原数值除以2。
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 = pyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;//MAX_ARRAY_SIZE和Integer.MAX_VALUE为常量，详细请参阅下⾯的注解
}
通过以上代码，我们可知java⾃动增加ArrayList⼤⼩的思路是：向ArrayList添加对象时，原对象数⽬加1如果⼤于原底层数组长度，则以适当长度新建⼀个原数组的拷贝，并修改原数组，指向这个新建数组。原数组⾃动抛弃（java垃圾回收机制会⾃动回收）。size则在向数组添加对象，⾃增1。注解：
//定义于该类的常量，⽤来分配数组的size最⼤值。⼀些 VMs在数组⾥保留字头，试图分配更⼤数组时可能导致OutOfMemoryError：被请求数组的size超出VM界限。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//在java.lang.Integer类中常量MIN_VALUE、MAX_VALUE如下：
public static final int  MIN_VALUE = 0x80000000;//整型取值区间下界：－2147483648
public static final int  MAX_VALUE = 0x7fffffff;//整型取值区间上界：2147483647
  //在java.util.AbstractList中modCount定义如下：
  protected transient int modCount = 0;
3、remove()⽅法
该重构⽅法其⼀源码如下（其它的就不累述了）：
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);//将后⾯的列表对象前移
elementData[--size] = null; // 数组前移⼀位，size⾃减，空出来的位置置null，具体的对象的销毁由Junk收集器负责return oldValue;
}
private void rangeCheck(int index) {//边界检查
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {//获取指定index所在位置的对象
return (E) elementData[index];
}
通过remove()源码的学习，我们不难看出，其改变ArrayList⼤⼩的核⼼与add()⽅法相似，都是同数组拷贝。
另外，如果确有必要，⽤户也可以指定ArrayList实例的容量，可以有效的降低时间成本。它是通过调⽤ensureCapacityInternal来实现的，源代码如下：
public void ensureCapacity(int minCapacity) {
if (minCapacity > 0)
ensureCapacityInternal(minCapacity);
}
因为size为private的，java给出⽅法来访问它：
public int size() {
checkForComodification();
return this.size;
}
综上所述，在⽤户向ArrayList追加对象时，Java总是要先计算容量（Capacity）是否适当，若容量不⾜则把原数组拷贝到以指定容量为长度创建的新数组内，并对原数组变量重新赋值，指向新数组。在这同时，size进⾏⾃增1。在删除对象时，先使⽤拷贝⽅法把指定index后⾯的对象前移1位（如果有的话），然后把空出来的位置置null，交给Junk收集器销毁，size⾃减1，即完成了。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。