ArrayList集合源码

DayMoonNight

已于 2022-02-16 21:51:47 修改

阅读量237

点赞数 1

文章标签： java arraylist 源码

于 2022-02-16 21:45:37 首次发布

本文链接：https://blog.csdn.net/qq_51510549/article/details/122970999

版权

一、ArrayList的特点:

ArrayList实现了动态可变的数组，由于内存为连续的地址，可进行随机访问，查询速度较快，但是是线程不安全的，ArrayList在增加数据的时候要进行数据空间的判断，如果不够则进行扩容

ArrayList集合实现了RandomAccess接口，该接口会使得随机访问比顺序访问快

ArrayList集合继承了AbstractList类，AbstractList类要求子类必须重写set方法，get方法，add方法

二、ArrayList的成员变量:

//默认数组容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空容量的数组，长度为0	
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//集合真正存储数据的容器
transient Object[] elementData; // non-private to simplify nested class access
//数组长度
private int size;
//数组的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

三、ArrayList的构造方法:

//无参构造方法
public ArrayList() {
	//赋值
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//用指定的初始容量构造一个空列表构造方法
public ArrayList(int initialCapacity) {
	//如果initialCapacity大于0则创建一个等大的数组
	if (initialCapacity > 0) {
		this.elementData = new Object[initialCapacity];
	//如果initialCapacity等于0则创建一个等大的数组
	} else if (initialCapacity == 0) {
		this.elementData = EMPTY_ELEMENTDATA;
	//小于0则出现异常
	} else {
		throw new IllegalArgumentException("Illegal Capacity: "+
										   initialCapacity);
	}
}

//构造一个包含指定集合的元素的列表
public ArrayList(Collection<? extends E> c) {
	//返回包含此集合中所有元素的数组给elementData
	elementData = c.toArray();
	//如果有数据
	if ((size = elementData.length) != 0) {
		// c.toArray might (incorrectly) not return Object[] (see 6260652)
		//判断当前类型是否为Object类型
		if (elementData.getClass() != Object[].class)
			//复制一份给elementData
			elementData = Arrays.copyOf(elementData, size, Object[].class);
	//没数据就赋值一个空的容量
	} else {
		// replace with empty array.
		this.elementData = EMPTY_ELEMENTDATA;
	}
}

四、ArrayList的add()方法:

1.add()方法:

//1.将指定元素插入集合
public boolean add(E e) {
	//调用ensureCapacityInternal方法，因为要添加数据所以传入当前长度加1
	//是否需要扩容
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	//把要添加的数据赋值给数组的下一个值
	elementData[size++] = e;
	return true;
}
//2.将指定元素插入集合指定位置
public void add(int index, E element) {
	//判断index是否越界
	rangeCheckForAdd(index);
	//判断是否扩容
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	//将index之后的所有元素向后移一位
	System.arraycopy(elementData, index, elementData, index + 1,
					 size - index);
	//在要插入的index索引位置赋值
	elementData[index] = element;
	//长度加1
	size++;
}

2.ensureCapacityInternal()方法:

//ensureCapacityInternal方法
//minCapacity:size + 1后的值
private void ensureCapacityInternal(int minCapacity) {
	//调用ensureExplicitCapacity方法
	//elementData:当前数组
	//minCapacity:最小容量
	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

3.calculateCapacity()方法:

//calculateCapacity方法:计算最小容量
//elementData:当前数组
//minCapacity:size + 1后的值
//DEFAULT_CAPACITY:默认值为10
private static int calculateCapacity(Object[] elementData, int minCapacity) {
	//如果elementData数组为空
	//则判断DEFAULT_CAPACITY和minCapacity返回较大的值
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		return Math.max(DEFAULT_CAPACITY, minCapacity);
	}
	//如果不为空返回minCapacity
	return minCapacity;
}

4.ensureExplicitCapacit()方法:

//ensureExplicitCapacit方法,扩容方法的入口
//minCapacity:calculateCapacity方法返回的值
private void ensureExplicitCapacity(int minCapacity) {
	//添加了元素改变了数组使得modCount++
	modCount++;
	// overflow-conscious code
	//是否满足扩容条件
	//如果当前数组的长度比传入进来的minCapacity小,
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);
}

5.grow()方法:扩容算法

//grow方法
//扩容算法
private void grow(int minCapacity) {
	// overflow-conscious code
	//oldCapacity:老的容量等于当前数组的长度
	int oldCapacity = elementData.length;
	//newCapacity:新的容量等于老的容量加上老的容量除以二
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	//如果扩容完的容量减去最小容量小于零，则把最小容量赋值给新容量
	if (newCapacity - minCapacity < 0)
		newCapacity = minCapacity;
	//如果新容量大于了MAX_ARRAY_SIZE则调用hugeCapacity方法
	//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
	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);
}

6.hugeCapacity()方法:

//超大容量算法
private static int hugeCapacity(int minCapacity) {
	//超出了最大值越界了
	if (minCapacity < 0) // overflow
		throw new OutOfMemoryError();
	//达到极限容量就返回Integer.MAX_VALUE或者MAX_ARRAY_SIZE
	return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

7.rangeCheckForAdd()方法:

private void rangeCheckForAdd(int index) {
    //检查给定的索引是否越界
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

五、ArrayList的remove()方法:

1.remove()方法:

//1.指定位置删除
public E remove(int index) {
	//检查索引
    rangeCheck(index);
	//更改了数组要使得modCount加一
    modCount++;
	//获取要删除的元素
    E oldValue = elementData(index);
	//将index+1及之后的元素向前移动一位，且不在最后一个，覆盖原来的数组
    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
	//返回删除的值
	return oldValue;
}	
//2.指定对象删除	
public boolean remove(Object o) {
	//传入进来的对象为null
	if (o == null) {
		//循环数组
		for (int index = 0; index < size; index++)
			//判断数组第一个中值为null的元素
			if (elementData[index] == null) {
				//调用快速删除方法
				fastRemove(index);
				return true;
			}
	//传入进来的对象为不为null
	} else {
		for (int index = 0; index < size; index++)
			//判断当前对象是否为传入的对象
			if (o.equals(elementData[index])) {
				//调用快速删除方法
				fastRemove(index);
				return true;
			}
	}
	//没有找到返回false
	return false;
}

2.rangeCheck()方法:

//rangeCheck()方法
//检查给定索引是否越界
private void rangeCheck(int index) {
    if (index >= size)
        hrow new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

3.elementData()方法:

//快速删除方法fastRemove()
//因为调用的时候永远不会越界所以不用判断索引，与remove(int index)方法类似
private void fastRemove(int index) {
    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
}

4.equals()方法:

//equals()方法
//重写了Object类的equals()方法
public boolean equals(Object obj) {
    return (this == obj);
}

5.遍历集合删除元素注意事项:

首先要了解:

在ArrayList中，modCount是指集合的修改次数,expectedModCount是指集合的迭代器的版本号，初始值是modCount，但是当集合进行add或者remove操作时，modCount会+1，而expectedModCount不会改变

当使用foreach遍历ArrayList的时候删除元素是会报错的
原因:foreach循环遍历容器本质上是使用迭代器进行遍历的，会对modCount进行检查，不允许集合进行更改操作

final void checkForComodification() {
    //判断是否一致
	if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
}

改进方法:

使用迭代器遍历remove()删除方法

会同步expectedModCount的值，把modCount的值赋予expectedModCount。所以不会抛出异常

public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    checkForComodification();

    try {
        ArrayList.this.remove(lastRet);  // 移除元素
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;    // 同步expectedModCount的值
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

六、结尾:

JDK版本不同的的时候的扩容算法

//JDK 1.6的扩容算法 1.5倍+1
int newCapacity = (oldCapacity * 3)/2 + 1;//扩容算法 8E
//JDK 1.7的扩容算法 1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍

集合元素扩容一定遵循最小扩容思想，但是尽量保证不出现直接2倍