java arraylist_java.util之一：ArrayList

ArrayList是java中的线性结构的一种表示方法，在java中使用频率非常高，下面来一步一步分析其底层的实现。(JDK1.8)

一、构造函数

ArrayList的构造函数有三个，分别如下，

我们最常使用的的无参的构造函数，那么无参的构造函数是如何定义的那，

publicArrayList() {this.elementData =DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

从上面看到无参构造函数，实际上是把elementData赋予了默认容量的一个数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA；

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

那么有参数的构造函数那，

public ArrayList(intinitialCapacity) {if (initialCapacity > 0) {this.elementData = newObject[initialCapacity];

}else if (initialCapacity == 0) {this.elementData =EMPTY_ELEMENTDATA;

}else{throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);

}

}

从上面可以看出首先判断给定的初始容量是否大于0，如果大于0则使用此值生成Object数组。如果等于0则和无参构造函数是一样的。如果小于0则抛出异常。在实际开发中强烈建议使用带参数的构造函数(为什么下面说)。

最后一个构造函数如下，

public ArrayList(Collection extends E>c) {

elementData=c.toArray();if ((size = elementData.length) != 0) {//c.toArray might (incorrectly) not return Object[] (see 6260652)

if (elementData.getClass() != Object[].class)

elementData= Arrays.copyOf(elementData, size, Object[].class);

}else{//replace with empty array.

this.elementData =EMPTY_ELEMENTDATA;

}

}

从上面的代码中可以看出，把集合类c调用toArray方法，返回其数组赋给elementData，然后对elementData进行判断如果长度不为0，这判断elementData的类型是否为Object，如果不是则使用Object进行替换，统一处理成Obejct的类型，因为在java中所有的类的父类都是Object。

二、成员变量

在ArrayList中主要的成员变量有elementData和size，elementData代表底层ArrayList的存储结构，即ArrayList是用数组来保存数据的；size指的是ArrayList中元素的个数(和elementData的长度区分开)。其他的成员变量像默认的初始容量为10。ArrayList在使用无参构造函数的时候分配内存的时候采用了懒加载的模式，即使用new ArrayList的时候底层不会分配空间，在真正向ArrayList中放元素的时候才会真正初始化数组长度。

三、常用方法

1、set/add

set和add方法的不同之处在于set方法会返回被覆盖的值，而add则不会

set(int index,E element)

在index处插入元素element，其具体实现如下

public E set(intindex, E element) {

rangeCheck(index);

E oldValue=elementData(index);

elementData[index]=element;returnoldValue;

}

从上面的代码中可以看出，首先需要判断index是否合法，

private void rangeCheck(intindex) {if (index >=size)throw newIndexOutOfBoundsException(outOfBoundsMsg(index));

}

也就是说如果index大于ArrayList中元素的个数，则抛出异常，这里有个疑问ArrayList是使用数组存储，默认长度是10，那么向ArrayList中添加一个元素后其数组的长度为10，ArrayList中的元素为1，为什么不允许index大于size插入那。

在判断完index不大于size后，把要插入的元素放在数组中下标为index的位置，返回之前的元素。

add(E e)

向ArrayList中插入元素e返回boolean类型，表示是否插入成功。

public booleanadd(E e) {

ensureCapacityInternal(size+ 1); //Increments modCount!!

elementData[size++] =e;return true;

}

可以看到首先要确保数组的容量，

private void ensureCapacityInternal(intminCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}

private static int calculateCapacity(Object[] elementData, intminCapacity) {if (elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {returnMath.max(DEFAULT_CAPACITY, minCapacity);

}returnminCapacity;

}

判断elementData是否为空数组，如果是空数组返回初始容量和size+1两个数中大的那个，这里应该返回初始容量10。

下个方法是，

private void ensureExplicitCapacity(intminCapacity) {

modCount++;//overflow-conscious code

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

如果minCapacity大于数组的长度则进行扩容，

private void grow(intminCapacity) {//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位(原大小的1.5倍)记为newCapacity。把要扩容到的大小和newCapacity比较，取两者中比较大的那个作为数组的容量。把原先的数组中的元素拷贝到新的数组中。

在回头来看add方法中的elementData[size++] = e;由于已经对数组进行了扩容，则可以把e放在size+1的位置上，返回true。

下面看add(int index,E e)

在index处插入e元素，

public void add(intindex, E element) {

rangeCheckForAdd(index);

ensureCapacityInternal(size+ 1); //Increments modCount!!

System.arraycopy(elementData, index, elementData, index + 1,

size-index);

elementData[index]=element;

size++;

}

验证index的合法性

private void rangeCheckForAdd(intindex) {if (index > size || index < 0)throw newIndexOutOfBoundsException(outOfBoundsMsg(index));

}

然后确定底层数组的容量，判断是否需要扩容，如果不需要则把e插入到index的位置，这里不是使用的循环移动插入，而是进行了数组的分部分拷贝，把index前的元素和index后的元素进行拷贝，最后把e插入在index处，这种方式比循环移动插入要快(使用底层的拷贝技术)。

2、get方法

根据index取得ArrayList中的元素，

public E get(intindex) {

rangeCheck(index);returnelementData(index);

}

判断给定的index的值比较和size的大小，如果超过了size则抛出异常，否则返回其index处的值。

3、contains(Object o)方法

判断o是否在ArrayList中，由于ArrayList使用数组存储元素，所以它是允许存重复值的，而contains方法返回的则是o第一次出现的位置。

public booleancontains(Object o) {return indexOf(o) >= 0;

}

public intindexOf(Object o) {if (o == null) {for (int i = 0; i < size; i++)if (elementData[i]==null)returni;

}else{for (int i = 0; i < size; i++)if(o.equals(elementData[i]))returni;

}return -1;

}

可以看到ArrayList中允许存null值，且可以存多个。

如果o不是null，则从头开始循环直到第一个为o的元素出现，返回其下标否则返回-1，最后根据indexOf的值大于0的返回true，否则false。

4、remove(int index)/remove(Object o)

从ArrayList中删除元素，可以按照索引和元素进行删除。按照元素删除仅会删除给定元素第一个的位置，其余不会删除。

remove(int index)

public E remove(intindex) {

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; //clear to let GC do its work

returnoldValue;

}

首先依然是判断删除位置是否合法。如果合法则取得要删除索引位置的元素值(返回)，因为要删除那么必然会进行数组的移动，即把删除位置后的数组向前移动，这里使用的是数组的拷贝。

remove(Object o)

按照元素进行删除，删除ArrayList中的第一个为o的元素，

public booleanremove(Object o) {if (o == null) {for (int index = 0; index < size; index++)if (elementData[index] == null) {

fastRemove(index);return true;

}

}else{for (int index = 0; index < size; index++)if(o.equals(elementData[index])) {

fastRemove(index);return true;

}

}return false;

}

这里仍然把null的情况单独处理，我们看不为null的情况的删除，使用size遍历整个数组，在数组中找到等于给定元素的下标，调用fastMove方法按照下标删除，只会把o第一次出现的位置上的元素删除，即重复的不会删除。

private void fastRemove(intindex) {

modCount++;int numMoved = size - index - 1;if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,

numMoved);

elementData[--size] = null; //clear to let GC do its work

}

上面还是按照下标进行删除。

未完待续。