ArrayList小结
ArrayList小结
ArrayList概述
特点：
- 基于数组，是动态可自动扩容的。
- 不是线程安全的。多线程可使用
Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，或使用JUC的CopyOnWriteArrayList类。 - 实现
Serializable接口，支持序列化，可通过序列化传输。 - 实现RandomAccess接口，支持快速随机访问（通过下标访问）
- 实现
Cloneable接口，可被克隆。 - 每个实例都有一个容量，容量会随着向其中添加元素而自动增长，伴随着旧数据向新数组的拷贝。
- 继承于
AbstractList抽象类。 - 可以存放null.
字段属性
// 数组的默认大小
private static final int DEFAULT_CAPACITY = 10;
// 空的数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
// 空数组实例，用于了解添加元素时数组膨胀多少
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 底层存放数据的数组，其长度就是ArrayList的容量，当为空时，其值等于上面字段，添加元素后变成EMPTY_ELEMENTDATA。
transient Object[] elementData;
// 当前数组存储的元素个数
private int size;
构造函数
// 默认无参构造器生成的数组初始容量为0
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 有参构造器：
// 1. 大于0 ==> 创建对应大小的数组
// 2. 等于0 ==> 创建空数组（区别于无参构造的空数组）
// 3. 小于0 ==> 抛出异常
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);
}
}
// 通过已有的集合创建ArrayList
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
this.elementData = EMPTY_ELEMENTDATA; // 若为空集合，则创建一个空数组
}
}
常用方法
添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 添加元素前，先确保容量足够
elementData[size++] = e;
return true;
}
// 确保底层数组容量足够
// minCapacity: 最低容量 = 已存元素个数+待存元素个数
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算所需的最小容量的大小
// 若使用无参构造器，初次插入元素后，数组容量为10
// 否则直接返回当前所需的最少容量 = 已存+待存
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
// 若当前容量小于所需的最小容量，进行扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++; // 提供快速失败，当生成迭代器后有发生修改，则抛出异常
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 数组扩容方法
// 1. 先扩充为原来容量的1.5倍，若满足最低容量要求并且不超过最大容量限制，则为1.5倍
// 2. 若原来的1.5倍还是不够，则取要求的最低容量
// 3. 若最低容量没有超过最大容量限制，则新数组容量为设定的最低容量
// 4. 若最低容量超过最大限制，则设置为int型能表示的最大值
// 5. 在设定好新容量后，将旧元素复制到新数组中
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // 扩充到原容量的1.5倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity; // 1.5倍不满足要求，则取要求的容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity); // 要求的容量超过数组最大容量，则设为int型表示的最大值
elementData = Arrays.copyOf(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;
}
数组容量扩充小结
- 若使用无参构造，则初始容量为0。
- 第一次添加元素时，创建容量为10的数组。
- 一直添加到第11个元素开始，数组采用1.5倍原来容量进行扩容。
- 若扩容达到数组最大容量时，设置数组容量为int型能表示的最大值。其后不再扩容。
- 若元素个数超过最大值，抛出
OutOfMemoryError异常。
删除元素
// 删除指定位置的元素
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; // 将最后原来最后一个元素设为null，使得GC对其回收
return oldValue; // 返回被删除的元素
}
// 删除指定的元素
// 会删除首次出现的元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) { // 若删除的元素为null,则使用 == 判断
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) { // 若删除的元素非null,则使用equals判断
fastRemove(index);
return true;
}
}
return false;
}
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; // 原最后一个元素设为null,使得GC对其进行回收
}
修改元素
// 修改指定位置的元素值,并返回原来的元素
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
查找元素
// 根据给定的索引查找元素
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
// 根据给定的元素获得首次出现时的位置
// 若该元素不在数组中,则返回-1
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;
}
// 注:lastIndexOf(Object o)是返回最后一次出现指定元素的位置
遍历集合
// 1. 通过for循环遍历
ArrayList list = new ArrayList();
for(int i = 0; i < list.size(); i++){
list.get(i);
}
// 2. 通过迭代器iterator遍历
ArrayList list = new ArrayList();
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
int val = it.next();
}
// 3. 使用forEach遍历
ArrayList list = new ArrayList();
for(int i : list){ // 通过Iterator迭代器实现
int val = i;
}
// 4. 通过迭代器ListIterator
ArrayList list = new ArrayList();
ListIterator<Integer> it = list.ListIterator();
while(it.hasNext()){ // 向后遍历
it.next();
}
while(it.hasPrevious()){ // 向前遍历
it.previous();
}
注:
- 使用迭代器进行遍历时,若对ArrayList进行增加或删除,会抛出异常
ConcurrentModificationException.可使用迭代器自己的remove() - 修改不会抛出异常.
- 迭代器只能向后遍历,可以删除元素,不能新增元素.
- ListIterator能向前遍历和向后遍历,可以新增元素.
子集合SubList
// 返回原数组指定范围的一个视图
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
注:
- 对视图的修改影响原数组,相当于对原数组采用相同的操作.
内存回收
// 将数组的容量设置为当前保存元素元素的个数
// 用于将多于的内存进行回收
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
参考:
本文来自博客园，作者：战五渣渣渣渣渣，转载请注明原文链接：https://www.cnblogs.com/truestoriesavici01/p/13213992.html
