概述
-
ArrayList是基于数组实现的集合类
-
正是基于数组的数据结构的原因，ArrayList具有增删慢，查询快的特点：
-
- 增删慢：每次增删元素，都要更改数组的长度、拷贝以及移动元素的位置
- 查询快：数组在内存上是一块连续的内存空间，所以可以根据地址+索引的方式快速获取对应位置上的元素
-
ArrayList允许空值和重复元素，当ArrayLIst中的元素数量大于底层允许数量的时候，ArrayList会通过扩容机制生成一个更大的数组
-
ArrayList是非线程安全的
ArrayList的继承关系
标记接口RandomAccess
public interface RandomAccess {
}
RandomAccess 是一个标记接口，标识实现该接口的类支持快速随机访问。
实现了RandomAccess后，使用for循环比使用迭代器遍历ArrayList效率更高，也就是代码片段一比代码片段二更快
片段一：
for (int i=0, n=list.size(); i < n; i++)
list.get(i);
片段二：
for (Iterator i=list.iterator(); i.hasNext(); )
i.next();
标记接口Cloneable
public interface Cloneable {
}
Cloneable也是一个标记接口，实现这个接口后，然后在类中重写Object中的clone()方法，然后调用该类的clone方法才能clone成功，如果不实现Cloneable接口，则会抛出CloneNotSupportedException异常。
Object中的clone()方法:
protected native Object clone() throws CloneNotSupportedException;
ArrayList中的clone()方法：
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
ArrayList的clone()方法复制的是ArrayList中元素的浅拷贝副本，也就是当list中元素发生变化的时候，两个list都会变化
ArrayList<User> arr1 = new ArrayList<User>();
User user01 = new User("小明", 12);
arr1.add(user01);
arr1.add(new User("小黑",13));
ArrayList<User> cloneArr = (ArrayList<User>) arr1.clone();
// 修改了user01
user01.setName("小红");
// clone list add元素
cloneArr.add(new User("小小",15));
// 原list通过下标修改元素
arr1.get(0).setAge(13);
// clone list通过下标修改元素
cloneArr.get(1).setAge(14);
System.out.println(arr1);
System.out.println(cloneArr);
运行结果：
[User{name='小红', age=13}, User{name='小黑', age=14}]
[User{name='小红', age=13}, User{name='小黑', age=14}, User{name='小小', age=15}]
标记接口Serializable
public interface Serializable {
}
Serializable接口是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。
List接口
List作为Collection集合的子接口，继承了Collection 接口中的全部方法，还增加了一些操作集合的特有方法
抽象类AbstractList
AbstractList是一个抽象类，既继承了AbstractCollection抽象类，拥有AbstractCollection的默认实现方法，同时也实现了List接口，为List接口方法添加了默认实现和拓展
ArrayList的属性
// 初始化默认容量
private static final int DEFAULT_CAPACITY = 10;
// ArrayList空实例共享一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 用于无参构造创建的空实例，与EMPTY_ELEMENTDATA区分开，用于区分第一次添加元素时需要创建的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 真正存储ArrayList中元素的数组
transient Object[] elementData; // non-private to simplify nested class access
// ArrayList 中元素的数量，注意不是elementData的长度
private int size;
// 数组的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
ArrayList的构造方法
带有初始化容量的构造方法
public ArrayList(int initialCapacity) {
// 判断容量参数的合法性
if (initialCapacity > 0) {
// 参数容量大于0，elementData初始化为参数initialCapcity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 参数等于0，elementdata初始化为空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
// 参数小于0，抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
无参构造
将elementData初始化为空数组DEFAULTCAPCITY_EMPTY_ELEMENTDATA
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
参数为Collection类型的构造方法
将collection集合转换为一个ArrayList
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
// collection集合长度大于0
if ((size = a.length) != 0) {
// 如果参数是ArrayList集合，ArrayList的toArray方法直接调用了Arrays.copyOf方法
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
// 其他类型的Collection复制到elementData
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// 集合参数长度等于0：elementData初始化为EMPTY_ELEMENTDATA
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
Arrays.copyOf()方法
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
// 复制数组
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
其他方法
trimToSize()
将此ArrayList实例的容量调整为实际元素数量的大小。应用程序可以使用此操作最小化ArrayList实例的存储。
public void trimToSize() {
// 修改次数自增
modCount++;
// 如果实际元素个数小于数组长度，那么就需要清楚数组中的空元素，然后将数组长度修改为当前实际元素的数量值
if (size < elementData.length) {
// 实际元素数量为0，即没有元素，则将elementData设置为EMPTY_ELEMENTDATA
// 元素个数大于0，则调用Arrays.copyOf生成一个长度为size的新数组，并赋值给elementData
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
由于ArrayList的扩容机制，elementData数组中的元素会存在空值，导致内存资源的浪费，这时就可以调用trimToSize()方法将elementData数组的长度变为实际的元素的长度，没有空值占用空间，就减少了资源的浪费
ensureCapacity(int minCapacity)
调用该方法，可以对底层数组进行扩容，如果指定的参数值大于当前数组长度，就会进行数组扩容
如果指定参数大于当前数组的1.5倍，数组扩容到指定参数的长度
如果指定参数小于当前数组的1.5倍，数组扩容到当前的1.5倍长度
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
在add多个元素之前，可以先调用该方法将数组预先设置到预计大小，以减少数组扩容次数，这样就可以大大提升速度
add(E e)方法
将指定元素添加到list的末尾
public boolean add(E e) {
// 因为要添加元素，可能会容量不够，所以添加之前先进行判断
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ensureCapacityInternal(int minCapacity)方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
calculateCapacity(Object[] elementData, int minCapacity)
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断elementData是否为空数组
// 使用无参构造的时候，elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 如果是那么 size+1 = 1 , 和DEFAULT_CAPACITY比较，取 10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
紧接着调用ensureExplicitCapacity方法更新modCount并判断是否需要扩容
ensureExplicitCapacity(int minCapacity)
private void ensureExplicitCapacity(int minCapacity) {
// 这里就是上面add方法中的注释：Increments modCount!!
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
// 扩容
grow(minCapacity);
}
grow(int minCapacity)
private void grow(int minCapacity) {
// overflow-conscious code
// 得到旧的数组长度
int oldCapacity = elementData.length;
// 计算新的数组长度：即旧数组程长度的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 检查新数组长度是否满足最小长度需求
// 如果没有满足，指定新数组长度为最小需求容量值，
// 上面ensureCapacity方法中，如果指定了数组长度大于当前数组长度的1.5倍，数组就会扩容到指定的长度
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 检查新容量是否超过了最大值，如果超过了最大值，使用hugeCapacity方法比较二者
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);
}
hugeCapacity(int minCapacity)
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 对minCapacity和MAX_ARRAY_SIZE进行比较
// 若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
// 若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
add方法流程总结
外部调用add方法，并传入要插入的元素
add方法调用ensureCapacityInternal方法来确保数组容量足够，记录modCount++，将传入的元素插入到数组的尾部
在ensureCapacityInternal方法中，调用了calculateCapacity和ensureCapacityInternal两个方法
calculateCapacity方法中主要判断了当时elementData是否是空数组，如果是返回10
ensureCapacityInternal方法中对modCount进行自增来记录操作次数，并判断是否需要扩容，如果需要扩容则调用grow方法进行扩容
在grow方法中，确定了新数组的长度，并将就数组的元素拷贝到新数组中
add(int index, E element)方法
将新元素插入至序列指定位置，需要先将该位置及其之后的元素都向后移动一位，为新元素腾出位置。这个操作的时间复杂度为O(N)，频繁移动元素可能会导致效率问题，特别是集合中元素数量较多时。在日常开发中，若非所需，我们应当尽量避免在大集合中调用第二个插入方法。
public void add(int index, E element) {
// 检查传入的index是否合法，如果大于当前数组元素的个数(当前个数不为0)或者传入的是负数则会抛出异常
rangeCheckForAdd(index);
// 检查当前数组是否有足够的空间（和上面的add(E e)一样）
ensureCapacityInternal(size + 1); // Increments modCount!!
// 将index及其之后的所有元素向后移动一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 将新元素插入到index位置
elementData[index] = element;
size++;
}
rangeCheckForAdd(int index)
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
remove方法
ArrayList支持两种删除元素的方式
按下标删除
public E remove(int index) {
// 检查下标是否合法，如果index >= size抛出IndexOutOfBoundsException异常
rangeCheck(index);
modCount++;
// 记录要移除的元素，作为返回值
E oldValue = elementData(index);
// 计算要移动的元素的数量
int numMoved = size - index - 1;
// 如果这个值大于0，说明要移除的元素后面还有元素，这些元素都要向前移动一位
// 如果等于0，说明要移除的是最后一个元素，则不需要移动其他元素
// System.arraycopy(源数组，源数据移动的起始位置，目标数组，目标数组的起始位置，要移动元素的个数)
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 移动后的数组size位置设置为null
// 多出的这个引用指向为null，gc就可以正确的回收内存
// size减一
elementData[--size] = null; // clear to let GC do its work
// 返回旧元素
return oldValue;
}
按元素删除
删除和参数匹配的第一个元素
public boolean remove(Object o) {
if (o == null) {
// 遍历找到第一个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;
}
fastRemove方法和上面remove方法差不多，先计算要移动的元素的数量，再移动元素，然后标记最后一个元素为null
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
}
batchRemove(Collection<?> c, boolean complement)
batchRemove方法在removeAll和retainAll方法中使用到
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;// 读，写两个下标
boolean modified = false;
try {
// 遍历数组，将要保留的元素移动到数组的前面
// w最后的值就是要保留的元素的数量
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
// r!=size表示可能出错了：c.contains(elementData[r])发生了异常
// 异常发生前的部分可以完成期望的操作，未被遍历到的部分会被接到后面
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
// 如果w==size，就表示元素全部保留了，没有删除操作发生，返回false
if (w != size) {
// clear to let GC do its work
// w之后的元素都指向null
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w; // 新的size为保留的元素的个数
modified = true;
}
}
return modified;
}
1059
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
