Java基础_模拟ArrayList集合

1. ArrayList的实现原理

在ArrayList类内部维护了一个数组(固定长度)来存储数据

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

	// 空数组，用来实例化不带容量大小的构造函数
	private static final Object[] EMPTY_ELEMENTDATA = {};

	// 保存ArrayList中数据的数组
	private transient Object[] elementData;

	// ArrayList中实际数据的数量
	private int size = 0;

在初始化集合时对数组elementData进行初始化, 默认的初始化容量为10;

1.1 初始化数组elementData

在ArrayList集合中有两个构造函数对elementData数组进行初始化
含有参数的:

public JDKArrayList(int initialCapacity) {
		super();
		if (initialCapacity < 0)
			throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
		this.elementData = new Object[initialCapacity];
	}

根据传入的初始化容量创建数组

无参的:

public JDKArrayList() {
		super();
		this.elementData = EMPTY_ELEMENTDATA;
	}

将EMPTY_ELEMENTDATA空数组赋给elementData数组

1.2 在向集合中添加数据,如果数组elementData中存储数据已满时, 对数组进行扩容

public boolean add(E e) {
		//在添加数据之前先判断elementData数组是否已满; 如果已满, 则进行扩充
		// size + 1 和 minCapacity: 代表elementData数组此时必须存在的最小容量;
		// size: 代表数组中已存入数据的数量, size初始化值为0; 
		ensureCapacityInternal(size + 1); 
		elementData[size++] = e;
		return true;
	}
	
private void ensureCapacityInternal(int minCapacity) {
		// 如果是个空数组,说明在使用无参构造函数初始化后并未存储数据
		if (elementData == EMPTY_ELEMENTDATA) {
			// 取minCapacity和初始化容量10的较大者(在数组最小容量小于默认容量时一律设置为默认容量10)
			minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
		}
		// 如果数组的最小容量可以存储添加的数据
		ensureExplicitCapacity(minCapacity);
	}
	
// 确保数组容量大于ArrayList中元素个数
private void ensureExplicitCapacity(int minCapacity) {
	    // 将“修改统计数”+1
		modCount++;
		// 如果实际数据容量大于数组容量，就给数组扩容
		if (minCapacity - elementData.length > 0)
			grow(minCapacity);
	}

// 增大数组空间
private void grow(int minCapacity) {
		// overflow-conscious code
		int oldCapacity = elementData.length;
		int newCapacity = oldCapacity + (oldCapacity >> 1); // 在原来容量的基础上加上
															// oldCapacity/2
		if (newCapacity - minCapacity < 0)
			newCapacity = minCapacity; // 最少保证容量和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);
	}

2、手写ArrayList集合

2.1首先创建集合接口

package com.lic.arrayList;
public interface MyList<E>{
	public boolean add(E object);

	public boolean add(int index, E object);

	public Object remove(int index);

	public boolean remove(E object);

	public int size();

	public Object get(int index);
	
}

2.2 创建实现类

package com.lic.arrayList;
import java.util.Arrays;
public class MyArrayList<E> implements MyList<E>{
	// 实际保存ArrayList数据的数组(长度固定)
	private Object[] elementData;

	// 数组默认初始化容量
	private static final int DEFAULT_CAPACITY = 10;

	// elementData数组中已存储元素的个数
	private int size = 0;

	// 创建有参构造函数(指定集合容量)
	public MyArrayList(int miniCatacity) {
		if (miniCatacity < 0) {
			throw new IllegalArgumentException("集合容量不能小于0");
		} else if (miniCatacity == 0) {
			elementData = new Object[DEFAULT_CAPACITY];
		}
		elementData = new Object[miniCatacity];
	}

	// 创建无参构造函数(不指定集合容量,使用默认集合容量)
	public MyArrayList() {
		this(DEFAULT_CAPACITY);
	}

	// 实现集合的add()方法
	public boolean add(E e) {
		// 1.先判断elementData数组是否已满,如果已满,则扩充该数组
		ensureCapacityInternal(size + 1);
		// 2.将元素加入数组中
		elementData[size++] = e;
		return true;
	}
	
    // 实现集合的add()方法:向指定位置插入数据
	public boolean add(int index, E newObject) {
		// 先判断elementData数组是否已满,如果已满,则扩充该数组
		ensureCapacityInternal(size + 1);
	   //在指定位置后(包括指定位置)有多少个数据需要向后移动
		int numAdded = size - index;
		System.arraycopy(elementData, index, elementData, index + 1, numAdded);
		elementData[index] = newObject;
		size++;
		return true;
	}
    //数组扩充
	private void ensureCapacityInternal(int minCapacity) {
		if (size == elementData.length) {
			// 计算出新的扩容容量(1.5倍扩容)
			int newCapacity = size + size >> 1;
			// 如果新的扩容容量小于最小扩容容量,则将最小扩容容量设置为新扩容容量(防止size为1时扩容出现扩容失败问题,所以将最小扩容容量设置为size+1);
			if (newCapacity < minCapacity) {
				newCapacity = minCapacity;
			}
			elementData = Arrays.copyOf(elementData, newCapacity);
		}
	}

	public E get(int index) {
		// 检查数组下标是否越界
		rangeCheck(index);
		return elementData(index);
	}
	
	@SuppressWarnings("unchecked")
	E elementData(int index) {
		return (E) elementData[index];
	}

	public void rangeCheck(int index) {
		if (index >= size || index < 0) {
			throw new IndexOutOfBoundsException("数组下标越界!");
		}
	}

	public E remove(int index) {
		// 检查数组下标是否越界
		rangeCheck(index);
		E oldObject = elementData(index);
		// 计算出即将删除的目标元素之后有多少个元素需要向前移动(如果使用elementData.length代替size,可以实现删除效果,但是效率略低;)
		int numMoved = size - 1 - index;
		if (numMoved > 0)
			System.arraycopy(elementData, index + 1, elementData, index, numMoved);
		// 此句有两个功能:1.将elementData数组中最后一个有效元素(非null元素)置为空; 2.将size减1
		elementData[--size] = null;
		return oldObject;
	}

	public boolean remove(E e) {
		if (e != null) {
			for (int i = 0; i < size; i++) {
				if (e.equals(elementData[i])) {
					remove(i);
					return true;
				}
			}
		}
		return false;
	}

	//返回数组有效长度
	public int size() {
		return size;
	}
}

3、Vector底层实现原理

Vector是线程安全的，但是性能比ArrayList要低。
ArrayList，Vector主要区别为以下几点：
(1) Vector是线程安全的，源码中有很多的synchronized可以看出，而ArrayList不是。导致Vector效率无法和ArrayList相比；
(2) ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；
(3) Vector可以设置capacityIncrement，而ArrayList不可以，从字面理解就是capacity容量，Increment增加，容量增长的参数。

private void grow(int minCapacity)
	    {
	        int oldCapacity = elementData.length;
	        int newCapacity = oldCapacity + ((capacityIncrement <= 0) ? oldCapacity : capacityIncrement);
	        if(newCapacity - minCapacity < 0)
	        	newCapacity = minCapacity;
	        if(newCapacity - MAX_ARRAY_SIZE> 0)
	        	newCapacity = hugeCapacity(minCapacity);
	        elementData = Arrays.copyOf(elementData, newCapacity);
	    }