Java集合之ArrayList源码解析

时间  2019-11-16
标签 java 集合 arraylist 源码 解析 栏目 Java 繁體版
原文   原文链接

原文地址java

ArrayList

ArrayList是List接口的 可变数组的实现。实现了全部可选列表操做，并容许包括 null 在内的全部元素。除了实现 List接口外，此类还提供一些方法来操做内部用来存储列表的数组的大小。ArrayList继承自 AbstractList<E>，这是一个抽象类对一些基础的list操做作了一些封装.实现了RandomAccess 标记接口，代表能够实现快速随机访问.实现了Cloneable接口的实现表示该容器具备Clone函数操做，Serializable是序列化。算法

每一个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它老是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增加。自动增加会带来数据向新数组的从新拷贝，所以，若是可预知数据量的大小，就可在构造ArrayList实例时指定其容量。数组

在添加大量元素前，应用程序也可使用ensureCapacity操做来增长ArrayList实例的容量，这能够减小递增式再分配的数量。网络

注意，此实现不是同步的。若是多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。数据结构

ArrayList这个数据结构比较简单，整体来讲，ArrayList底层结构是数组，他的不少方法都是从数组上面演变而来的。dom

下面咱们先来看一下ArrayList中的一些初始值ide

//经过ArrayList实现的接口可知，其支持随机访问，能被克隆，支持序列化
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    //序列版本号
    private static final long serialVersionUID = 8683452581122892189L;

&emsp;&emsp;//默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    //空实例的共享空数组实例
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //被用于默认大小的空实例的共享数组实例。
	//与EMPTY_ELEMENTDATA的区别是：当咱们向数组中添加第一个元素时，知道数组该扩充多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /** * Object[]类型的数组，保存了添加到ArrayList中的元素。ArrayList的容量是该Object[]类型数组的长度 * 当第一个元素被添加时，任何空ArrayList中的elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA将会被 * 扩充到DEFAULT_CAPACITY（默认容量）。 */
	 transient Object[] elementData; //没有被私有化是为了简化内部类访问

    // ArrayList的大小（指其所含的元素个数）
    private int size;
	
	// 记录被修改的次数 
	protected transient int modCount = 0;  
	
	// 数组的最大值 
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8  

}
复制代码

elementData 是"Object[] 类型的数组"，它保存了添加到ArrayList中的元素。实际上，elementData是个动态数组，咱们能经过构造函数 ArrayList(intinitialCapacity)来执行它的初始容量为initialCapacity；若是经过不含参数的构造函数ArrayList()来建立ArrayList，则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增加而动态的增加，具体的增加方式请看这里函数

构造函数

ArrayList提供了三种方式的构造器。能够构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表。ui

这些元素按照该collection的迭代器返回的顺序排列的。this

// 构造一个指定初始容量的空列表
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);
	}
}

// 构造一个默认初始容量为10的空列表
public ArrayList() {   //这里并无初始化，jdk 1.8以后是在进行add操做后初始化 
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回的顺序排列的
public ArrayList(Collection<? extends E> c) {
	elementData = c.toArray();
	if ((size = elementData.length) != 0) { 
		// c.toArray()可能不会正确地返回一个 Object[]数组，那么使用Arrays.copyOf()方法
		if (elementData.getClass() != Object[].class)
			elementData = Arrays.copyOf(elementData, size, Object[].class);
	} else {     // 若是指定的collection为空
		this.elementData = EMPTY_ELEMENTDATA;
	}
}
复制代码

使用无参构造器，默认初始容量为何是10？

  1. 初始时：this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; size = 0;

  2. 向数组中添加第一个元素时，add(E e)方法中调用了ensureCapacityInternal(size + 1)方法，即ensureCapacityInternal(1)；

  3. 在ensureCapacityInternal(int minCapacity)方法中，minCapacity=DEFAULT_CAPACITY=10，而后再调用ensureExplicitCapacity(minCapacity)方法，即ensureExplicitCapacity(10)；

  4. 在ensureExplicitCapacity(minCapacity)方法中调用grow(minCapacity)方法，即grow(10)，此处为真正具体的数组扩容的算法，在此方法中，经过elementData = Arrays.copyOf(elementData, 10)具体实现了elementData数组初始容量为10的构造。

具体的扩容算法的实现请看这里

添加元素

// 在数组末尾加上一个元素
public boolean add(E e) {
	ensureCapacityInternal(size + 1);  // 进行扩容检查
	elementData[size++] = e;
	return true;
}

// 在数组的指定位置添加元素
public void add(int index, E element) {
	rangeCheckForAdd(index);   // 检查index是否越界

	ensureCapacityInternal(size + 1);  // 进行扩容检查
	
	// 对数据进行复制操做，空出index位置，并插入element，将源数组中从index位置开始后的size-index个元素统一后移一位
	System.arraycopy(elementData, index, elementData, index + 1,
					 size - index);
	elementData[index] = element;
	size++;    // 元素个数加1
}

// 按照指定collection集合的迭代器所返回的元素顺序，将该collection中的全部元素添加到列表的尾部
public boolean addAll(Collection<? extends E> c) {
	Object[] a = c.toArray();      // 将collection转换为数组类型
	int numNew = a.length;         // collection中的元素个数
	ensureCapacityInternal(size + numNew);  // 进行扩容检查
	System.arraycopy(a, 0, elementData, size, numNew);    // 将数组a[0,...,numNew-1]复制到数组elementData[size,...,size+numNew-1]
	size += numNew;
	return numNew != 0;
}

// 按照指定collection集合的迭代器所返回的元素顺序，将该collection中的全部元素添加到列表的指定位置
public boolean addAll(int index, Collection<? extends E> c) {
	rangeCheckForAdd(index);    // 检查index是否越界

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacityInternal(size + numNew);  // 进行扩容检查

	// 将数组elementData[index,...,index+numMoved-1]复制到elementData[index+numMoved,...,index+2*numMoved-1]
    //将源数组中从index位置开始的后numMoved个元素统一后移numNew位
	int numMoved = size - index;
	if (numMoved > 0)    
		System.arraycopy(elementData, index, elementData, index + numNew,
						 numMoved);

	// 将数组a[0,...,numNew-1]复制到数组elementData[index,...,index+numNew-1]完成数据的插入 
	System.arraycopy(a, 0, elementData, index, numNew);
	size += numNew;
	return numNew != 0;
}
复制代码

扩容相关

// 用于自定义设置ArrayList的容量
public void ensureCapacity(int minCapacity) {
	int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
		? 0
		: DEFAULT_CAPACITY;

	if (minCapacity > minExpand) {
		ensureExplicitCapacity(minCapacity);
	}
}

// 进行扩容检查
private void ensureCapacityInternal(int minCapacity) {
	//第一次add操做初始化，若是为空ArrayList，那么初始化容量为10
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
	}
	//判断是否须要扩容
	ensureExplicitCapacity(minCapacity);
}

//判断是否须要扩容
private void ensureExplicitCapacity(int minCapacity) {
	//modCount这个参数运用到了 fail-fast 机制
	modCount++;
	
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);   // 扩容
}

// 扩容
private void grow(int minCapacity) {
	int oldCapacity = elementData.length;
	//newCapacity为之前的1.5倍
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	if (newCapacity - minCapacity < 0)
		newCapacity = minCapacity;
	//判断容量是否到达long int 最大临界值
	if (newCapacity - MAX_ARRAY_SIZE > 0)
		newCapacity = hugeCapacity(minCapacity);
	// 对数组进行复制处理
	elementData = Arrays.copyOf(elementData, newCapacity);
}

// 检查是否超过最大容量 0x7fffffff ，是否抛出异常
private static int hugeCapacity(int minCapacity) {
	if (minCapacity < 0) // overflow
		throw new OutOfMemoryError();
	return (minCapacity > MAX_ARRAY_SIZE) ?
		Integer.MAX_VALUE :
		MAX_ARRAY_SIZE;
}
复制代码

删除元素

// 删除指定位置的元素
public E remove(int index) {
	rangeCheck(index);    //数组越界检查
	modCount++;
	E oldValue = elementData(index);
	int numMoved = size - index - 1;      //计算数组须要复制的数量
	if (numMoved > 0)   //将index后的数据都向前移一位
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);

	elementData[--size] = null;   //help GC
	return oldValue;
}

// 删除指定内容的元素（只删除第一个匹配成功的）
public boolean remove(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;
}

//找到对应的元素后，删除。删除元素后的元素都向前移动一位
private void fastRemove(int index) {
	modCount++;
	int numMoved = size - index - 1;
	if (numMoved > 0)     // 将index后面的元素总体向前移动一位
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);
	elementData[--size] = null; // help GC
}

//清空ArrayList，将所有的元素设为null
public void clear() {
	modCount++;

	for (int i = 0; i < size; i++)    // help GC
		elementData[i] = null;

	size = 0;
}

//删除ArrayList中从fromIndex到toIndex（区间--左闭右开）之间全部的元素
protected void removeRange(int fromIndex, int toIndex) {
	modCount++;
	int numMoved = size - toIndex;  //需向前移动的元素的个数
	System.arraycopy(elementData, toIndex, elementData, fromIndex,
					 numMoved);

	// help GC
	int newSize = size - (toIndex-fromIndex);
	for (int i = newSize; i < size; i++) {
		elementData[i] = null;
	}
	size = newSize;
}

//删除ArrayList中包含在指定容器c中的全部元素
public boolean removeAll(Collection<?> c) {
	Objects.requireNonNull(c);  //检查指定的对象c是否为空
	return batchRemove(c, false);
}

//移除ArrayList中不包含在指定容器c中的全部元素，与removeAll(Collection<?> c)正好相反
public boolean retainAll(Collection<?> c) {
	Objects.requireNonNull(c);     //检查指定的对象c是否为空
	return batchRemove(c, true);
}

// 根据complement的值删除元素
private boolean batchRemove(Collection<?> c, boolean complement) {
	final Object[] elementData = this.elementData;
	int r = 0, w = 0;    //读写双指针 w是从新存元素时的索引，r是原来的索引
	boolean modified = false;
	try {
		//遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
		//简单点：若保留，就将相同元素移动到前段；若删除，就将不一样元素移动到前段
		for (; r < size; r++)
			if (c.contains(elementData[r]) == complement)  //判断指定容器c中是否含有elementData[r]元素
				elementData[w++] = elementData[r];
	}finally {//确保异常抛出前的部分能够完成指望的操做，而未被遍历的部分会被接到后面
		//r!=size表示可能出错了：c.contains(elementData[r])抛出异常
		if (r != size) {
			System.arraycopy(elementData, r,elementData, w,size - r);
			w += size - r;
		}
		//若是w==size：表示所有元素都保留了，因此也就没有删除操做发生，因此会返回false；反之，返回true，并更改数组
		//而w!=size的时候，即便try块抛出异常，也能正确处理异常抛出前的操做，由于w始终为要保留的前段部分的长度，数组也不会所以乱序
		if (w != size) {
			for (int i = w; i < size; i++)
				elementData[i] = null;
			modCount += size - w;//改变的次数
			size = w;   //新的大小为保留的元素的个数
			modified = true;
		}
	}
	return modified;
}
复制代码

removeAll和retainAll方法：实现删除或保留ArrayList中包含Collection c中的的元素。

这两个方法都用到batchRemove方法（boolean complement使得batchRemove方法获得了重用）

下面以removeAll为例，分析batchRemove(c, false)

遍历elementData

若是集合c中包含elementData的元素e，则c.contains(elementData[r])为true，if不成立，if结束；若是c不包含elementData的元素e，则if成立，将此元素e赋值给elementData[w++] （即elementData保留了c中没有的元素，也就是删除了c中存在的全部元素。）

执行finally

finally是无论try中结果如何都会执行的。if(r!=size)，则将elementData未参加比较的元素arraycopy到elementData后面；新索引w加上刚arraycopy的数目；if (w != size)，此时w还不等于size，则将w后的元素移除.只有执行了if (w != size)（事实上只要c中含有elementData的元素，w确定不等于size），才令modified = true，才说明remove成功，返回true，不然返回false。

ArrayList中还有一个用于节约数组内存空间，缩小容量的方法

// 由于容量经常会大于实际元素的数量。内存紧张时，能够调用该方法删除预留的位置，调整容量为元素实际数量。
// 若是肯定不会再有元素添加进来时也能够调用该方法来节约空间
public void trimToSize() {
	modCount++;
	// length是数组长度，size表示数组内元素个数 
    // size<length那么就说明数组内有空元素，进行缩小容量操做 
	if (size < elementData.length) {
		elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
	}
}
复制代码

去掉预留元素的位置。返回一个新数组，新数组不含null，数组的size和elementData.length相等，以节省空间。此函数可避免size很小但elementData.length很大的状况。

ArrayList会每次增加会预申请多一点空间，1.5倍，这样就会出现当size() = 10的时候，ArrayList已经申请了15空间， trimToSize就是删除多余的5，只留10。

或许有人会有疑问： 调用Arrays.copyOf复制size长度的元素到elementData，并且由源码看应该是从0复制到size处，那么若是我以前调用过add(int index, E element)呢？好比，list={1，2，3，null，null，4，null，null}，若是调用trimToSize返回的应该是list={1，2，3，null}（由于size=4）。其实上面这种状况不会发生的，由于调用add(int index, E element)时，会检查index的合法性，因此list的元素确定是相邻的，而不会出现上述这种中间出现null的状况。

修改元素

// 将指定位置的元素改成指定的值 
public E set(int index, E element) {
	rangeCheck(index);    // 检查index是否越界

	E oldValue = elementData(index);
	elementData[index] = element;
	return oldValue;
}
复制代码

查找元素

//判断ArrayList中是否包含Object(o)
public boolean contains(Object o) {
	return indexOf(o) >= 0;
}

//返回一个值在数组首次出现的位置，会根据是否为null使用不一样方式判断。不存在就返回-1。时间复杂度为O(N)
public int indexOf(Object o) {
	if (o == null) {
		for (int i = 0; i < size; i++)                 
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = 0; i < size; i++)
			if (o.equals(elementData[i]))
				return i;
	}
	return -1;
}

//返回一个值在数组最后一次出现的位置，不存在就返回-1。时间复杂度为O(N)
public int lastIndexOf(Object o) {
	if (o == null) {
		for (int i = size-1; i >= 0; i--)
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = size-1; i >= 0; i--)
			if (o.equals(elementData[i]))
				return i;
	}
	return -1;
}

//返回指定位置的值，由于是数组，因此速度特别快
@SuppressWarnings("unchecked")
E elementData(int index) {
	return (E) elementData[index];
}

//返回指定位置的值，可是会检查这个位置数否超出数组长度
public E get(int index) {
	rangeCheck(index);

	return elementData(index); //实质上return (E) elementData[index]
}
复制代码

序列化

//保存数组实例的状态到一个流（即它序列化）。写入过程数组被更改会抛出异常
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
	int expectedModCount = modCount;
	s.defaultWriteObject(); //执行默认的反序列化/序列化过程。将当前类的非静态和非瞬态字段写入此流
	// 写入大小
	s.writeInt(size);
	// 按顺序写入全部元素
	for (int i=0; i<size; i++) {
		s.writeObject(elementData[i]);
	}
	if (modCount != expectedModCount) {
		throw new ConcurrentModificationException();
	}
}
//上面是写，这个就是读了。
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
	elementData = EMPTY_ELEMENTDATA;
	// 执行默认的序列化/反序列化过程
	s.defaultReadObject();
	// 读入数组长度
	s.readInt();
	if (size > 0) {
		ensureCapacityInternal(size);
		Object[] a = elementData;
		//读入全部元素
		for (int i=0; i<size; i++) {
			a[i] = s.readObject();
		}
	}
}
复制代码

为何要自定义序列化、反序列化机制呢？

因为ArrayList实质上是一个动态数组，每每数组中会有空余的空间，若是采用默认的序列化机制，那些空余的空间会做为null写入本地文件或者在网络中传输，耗费了没必要要的资源。因此，ArrayList使用自定义序列化机制，仅写入索引为【0，size）的有效元素以节省资源

迭代器

//返回ListIterator，开始位置为指定参数
public ListIterator<E> listIterator(int index) {
	if (index < 0 || index > size)
		throw new IndexOutOfBoundsException("Index: "+index);
	return new ListItr(index);
}

//返回ListIterator，开始位置为0
public ListIterator<E> listIterator() {
	return new ListItr(0);
}

//返回普通迭代器
public Iterator<E> iterator() {
	return new Itr();
}

//通用的迭代器实现
private class Itr implements Iterator<E> {
	int cursor;       //游标，下一个元素的索引，默认初始化为0
	int lastRet = -1; //上次访问的元素的位置
	int expectedModCount = modCount;//迭代过程不容许修改数组，不然就抛出异常
	//是否还有下一个
	public boolean hasNext() {
		return cursor != size;
	}
	//下一个元素
	@SuppressWarnings("unchecked")
	public E next() {
		checkForComodification();//检查数组是否被修改
		int i = cursor;
		if (i >= size)
			throw new NoSuchElementException();
		Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length)
			throw new ConcurrentModificationException();
		cursor = i + 1; //向后移动游标
		return (E) elementData[lastRet = i];    //设置访问的位置并返回这个值
	}
	//删除元素
	public void remove() {
		if (lastRet < 0)
			throw new IllegalStateException();
		checkForComodification();//检查数组是否被修改
		try {
			ArrayList.this.remove(lastRet);
			cursor = lastRet;
			lastRet = -1;
			expectedModCount = modCount;
		} catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		}
	}
	@Override
	@SuppressWarnings("unchecked")
	public void forEachRemaining(Consumer<? super E> consumer) {
		Objects.requireNonNull(consumer);
		final int size = ArrayList.this.size;
		int i = cursor;
		if (i >= size) {
			return;
		}
		final Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length) {
			throw new ConcurrentModificationException();
		}
		while (i != size && modCount == expectedModCount) {
			consumer.accept((E) elementData[i++]);
		}
		cursor = i;
		lastRet = i - 1;
		checkForComodification();
	}
	//检查数组是否被修改
	final void checkForComodification() {
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
	}
}

//ListIterator迭代器实现
private class ListItr extends Itr implements ListIterator<E> {
	ListItr(int index) {
		super();
		cursor = index;
	}
	public boolean hasPrevious() {
		return cursor != 0;
	}
	public int nextIndex() {
		return cursor;
	}
	public int previousIndex() {
		return cursor - 1;
	}
	@SuppressWarnings("unchecked")
	public E previous() {
		checkForComodification();
		int i = cursor - 1;
		if (i < 0)
			throw new NoSuchElementException();
		Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length)
			throw new ConcurrentModificationException();
		cursor = i;
		return (E) elementData[lastRet = i];
	}
	public void set(E e) {
		if (lastRet < 0)
			throw new IllegalStateException();
		checkForComodification();
		try {
			ArrayList.this.set(lastRet, e);
		} catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		}
	}
	public void add(E e) {
		checkForComodification();
		try {
			int i = cursor;
			ArrayList.this.add(i, e);
			cursor = i + 1;
			lastRet = -1;
			expectedModCount = modCount;
		} catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		}
	}
}
复制代码

Iterator与ListIterator的区别：

  1. Iterator能够应用于全部的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型；
  2. Iterator只能实现顺序向后遍历，ListIterator可实现顺序向后遍历和逆向（顺序向前）遍历；
  3. Iterator只能实现remove操做，ListIterator能够实现remove操做，add操做，set操做。

其余方法

//返回ArrayList的大小（元素个数）
public int size() {
	return size;
}

//判断ArrayList是否为空
public boolean isEmpty() {
	return size == 0;
}

//返回此 ArrayList实例的浅拷贝（元素自己没有被复制，复制过程数组发生改变会抛出异常）
public Object clone() {
	try {
		ArrayList<?> v = (ArrayList<?>) super.clone();
		v.elementData = Arrays.copyOf(elementData, size);
		v.modCount = 0;
		return v;
	} catch (CloneNotSupportedException e) {
		throw new InternalError(e);
	}
}
/* 浅克隆就是咱们所看到的Arrays.copyOf， System.arraycopy，数组是新的，可是里面N个元素全是引用的旧的。 浅拷贝(影子克隆):只复制基本类型。 深拷贝(深度克隆):基本类+对象。 */

//返回一个包含ArrayList中全部元素的数组
public Object[] toArray() {
	return Arrays.copyOf(elementData, size);
}

// 返回一个数组，使用运行时肯定类型，该数组包含在这个列表中的全部元素（从第一到最后一个元素）
// 返回的数组容量由参数和本数组中较大值肯定
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
	if (a.length < size)
		// Make a new array of a's runtime type, but my contents:
		return (T[]) Arrays.copyOf(elementData, size, a.getClass());
	System.arraycopy(elementData, 0, a, 0, size);
	if (a.length > size)
		a[size] = null;
	return a;
}
复制代码

ArrayList相关问题

Integer.MAX_VALUE - 8 这里为何要减去8？

主要是考虑到不一样的JVM,有的VM会在加入一些数据头,当扩容后的容量大于MAX_ARRAY_SIZE,咱们会去比较最小须要容量和MAX_ARRAY_SIZE作比较,若是比它大, 只能取Integer.MAX_VALUE,不然是Integer.MAX_VALUE -8。 这个是从jdk1.7开始才有的

jdk1.8的无参构造函数和以前版本的构造函数有什么区别?

jdk1.6
public ArrayList() {    
    this(10);    
} 

jdk1.7
public ArrayList() {    
    super();    
    this.elementData = EMPTY_ELEMENTDATA;    
}

jdk1.8
public ArrayList() {    
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    
}  
复制代码

对比下能够看出：jdk1.6的无参构造方法（默认构造方法）构造的ArrayList的底层数组elementData大小（容量）默认为10；从1.7开始，无参构造方法构造的ArrayList的底层数组elementData大小默认为0。

java集合类在jdk1.7版本基本上都有一种改动：懒初始化。懒初始化指的是默认构造方法构造的集合类，占据尽量少的内存空间（对于ArrayList来讲，使用空数组来占据尽可能少的空间，不使用null是为了不null判断），在第一次进行包含有添加语义的操做时，才进行真正的初始化工做。

1.7开始的ArrayList，默认构造方法构造的实例，底层数组是空数组，容量为0，在进行第一次add/addAll等操做时才会真正给底层数组赋非empty的值。若是add/addAll添加的元素小于10，则把elementData数组扩容为10个元素大小，不然使用恰好合适的大小（例如，第一次addAll添加6个，那么扩容为10个，第一次添加大于10个的，好比24个，扩容为24个，恰好合适）

1.8版本，默认构造的实例这个行为没有改变，只是用的数组名字变了。

jdk1.6中扩容算法的缺陷

（因为jdk1.7和jdk1.8在扩容算法方面差异不大，因此下面没有严格区分）

jdk1.6
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);  
    }  
} 
复制代码

从上面的代码能够看出jdk1.6的ensureCapacity方法只是简单进行了逻辑上的操做，没有过多考虑int型溢出的问题，从1.7开始对这个进行了完善。

并且没考虑入参minCapacity可能由于int溢出变为负数。这个方法能够外部手动调用，手动扩容传入负数这个确定是应该拦截掉的。可是自动扩容会由于int溢出产生负数，碰到这种状况时应该特殊处理，而不是什么都不作，等着后面抛出一个ArrayIndexOutOfBoundsException。

还有就是下面这句代码会形成过早溢出

int newCapacity = (oldCapacity * 3)/2 + 1;
复制代码

虽然上面这行代码和1.7开始的oldCapacity + (oldCapacity >> 1) 差很少，都是至关于1.5倍，但其实是有 区别的。

这里主要有两个区别

第一个区别是jdk1.6的乘除运算的数学结果比后面一个大1好比oldCapacity=10，1.6的 算法获得16，1.7开始的算法获得15，这个影响不大；

第二个区别就是二者在数字比较大时运算结果不同，好比 oldCapacity=10^9，这个数和Integer.MAX_VALUE位数同样，用1.6的算法获得的会是错误的-647483647，用 1.7的则是正确的1500000000，这时候明明能够1.5倍扩容，可是jdk1.6却用的是按需扩容。

ensureCapacity（称之为手动，是由于此方法是public的，能够外部手动调用）。 在1.6版本是只有这个手动的方法，内部自动操做也是调用这个方法，1.7开始进行了区分，而且进一步改进了扩容操做。

  • 从1.7开始将内部扩容和外部能够调用的扩容方法分开了，经过源码能够看出：外部调用的手动扩容方法ensureCapacity要多一个判断条件 minCapacity > minExpand，这个判断条件拦截掉负数的minCapacity，这样调用内部扩容ensureCapacityInternal方法时，minCapacity必定是正数；内部扩容方法直接就用minCapacity - elementData.length > 0判断，此条件能够检测出int型溢出，碰到溢出最后会抛出一个OOM错误。jdk1.7用OOM，这比jdk1.6用ArrayIndexOutOfBoundsException更好，由于此时数组大小超出了虚拟机对数组的限制，虚拟机没法处理这种状况了，抛出一个ERROR是合理的。

  • 使用这行代码

newCapacity = oldCapacity + (oldCapacity >> 1);
复制代码

这行代码不只仅是使用位运算加快执行速度，上面说了，这种作法才是对的，是真正的1.5倍。不只仅由于那一个大小的差异，更重要的是避免过早出现int溢出的状况，保证了内部自动扩容会尽可能按规定的策略执行。同时整个扩容处理流程中多增长了几处if判断，对各类状况处理更加完善。

为何ArrayList自动容量扩充选择扩充1.5倍？

这种算法构造出来的新的数组长度的增量都会比上一次大( 并且是愈来愈大) ，避免频繁newInstance 的状况。

为何ArrayList 不适合频繁插入和删除操做？

由上面分析的增长删除方法能够看出在ArrayList中常常会调用 System.arraycopy 这个效率很低的操做来复制数组，因此致使ArrayList在插入和删除操做中效率不高。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程