成员变量
//这个常量用于序列化机制，确保在反序列化时能够正确识别对象的版本。
private static final long serialVersionUID = 8683452581122892189L;
//创建对象时如果没有指定数组大小，则默认的数组大小为10
private static final int DEFAULT_CAPACITY = 10;
//在ArrayList为空时，elementData字段将被赋值为这个空数组。
private static final Object[] EMPTY_ELEMENTDATA = {};
//调用无参构造时会使用的默认数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/*这个数组是ArrayList用来存储元素的缓冲区。名为elementData的Object数组，它是transient的，意
味着它不会被序列化。*/
transient Object[] elementData;
//表示数组中的元素个数
private int size;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;构造方法
1、ArrayList(int initialCapacity)；创建指定容量的集合
//initialCapacity为创建该的对象时指定的初始容量
public ArrayList(int initialCapacity) {
//当容量大于0时直接创建指定容量大小的数组
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
}
//当参数为0时集合数组被赋值为上文已经定义好的空数组EMPTY_ELEMENTDATA
else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
}
//当数组小于0时抛出异常
else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
1.1使用方法
// 使用指定的初始容量创建一个ArrayList
int a = 10; // 指定初始容量
ArrayList<Integer> numbers = new ArrayList<>(a);
// 现在你可以向ArrayList中添加元素
for (int i = 0; i < a; i++) {
numbers.add(i); // 添加元素
}
// 输出ArrayList中的元素
System.out.println(numbers);2、 ArrayList()；默认构造方法
public ArrayList() {
//将上文定义好的无参构造数组传给elementData
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
这个默认构造方法使得ArrayList在没有指定初始容量时，可以以最小的内存占用开始，然后在添加元素时动态地增长其容量。
2.1使用方法
// 使用无参构造方法创建一个ArrayList
ArrayList<String> names = new ArrayList<>();3、ArrayList(Collection<? extends E> c)；
这个构造方法允许传入实现了Collection接口的任何E元素或者E元素的子类元素。
public ArrayList(Collection<? extends E> c) {
/*c.toArray()方法被调用来将集合c转换为一个Object数组a。这个数组包含了被传入的集合中的所有元素。*/
Object[] a = c.toArray();
//判断被传入的集合长度是否为0，即集合是否为空
if ((size = a.length) != 0) {
//判断被传入的集合是否为ArrayList的实例
if (c.getClass() == ArrayList.class) {
//如果c是ArrayList的实例，则直接将数组a传给elementData
elementData = a;
} else {
/*如果c不是ArrayList的实例，为了确保elementData的类型正确，使用Arrays.copyOf方法来创建一个新的数组，这个新数组的长度与a相同，并且是Object[]类型的。*/
elementData = Arrays.copyOf(a, size, Object[].class);
}
}
//如果集合c为空，则将elementData设置为定义好的默认空数组EMPTY_ELEMENTDATA
else {
elementData = EMPTY_ELEMENTDATA;
}
}这个构造方法允许用户快速地将任何集合转换为ArrayList实例，同时确保了类型安全和性能。如果传入的集合本身就是一个ArrayList，那么它的内部数组可以直接被新创建的ArrayList使用，避免了不必要的数组复制。
3.1使用方法
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
// 使用集合作为参数创建一个ArrayList
ArrayList<String> fruits = new ArrayList<>(list);
// 输出ArrayList中的元素
System.out.println(fruits);成员方法
1、add方法
1.1add(E e)；
默认在数组末尾添加新元素
public boolean add(E e) {
//调用这个方法可以确保 ArrayList 有足够的空间来存储新元素（下文会提及这个方法）
ensureCapacityInternal(size + 1);
//将元素e放置在数组最后一个位置
elementData[size++] = e;
//添加成功返回true
return true;
}
1.2add(int index, E element)；
用于在指定的索引位置插入一个元素
public void add(int index, E element) {
//检查索引index的合法性
rangeCheckForAdd(index);
//确保 ArrayList 有足够的空间来存储新元素
ensureCapacityInternal(size + 1);
//用来将数组中从index索引开始到末尾的元素向后移动一个位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//将要添加的元素放入index下标的位置
elementData[index] = element;
//将数组有效元素个数加1
size++;
}
与上文中相对应的add()方法结构基本相同，就不做详细解释了
1.3addAll(Collection<? extends E> c)；
用于将指定集合 c 中的所有元素追加到 ArrayList 的末尾。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}1.4addAll(int index, Collection<? extends E> c)；
用于将指定集合 c 中的所有元素插入到 ArrayList 中指定的索引位置。
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}2、grow方法及其内部方法
private void grow(int minCapacity) {
//将当前数组大小赋值给oldCapacity
int oldCapacity = elementData.length;
//将当前数组长度扩大为原数组的1.5倍
//(oldCapacity >> 1)将转为二进制后右移一个单位，得到的值为原来值的一半
int newCapacity = oldCapacity + (oldCapacity >> 1);
//判断扩大后的长度是否小于传入的所需长度
if (newCapacity - minCapacity < 0)
//如果扩大后的长度是否小于传入的所需长度，则将所需长度直接传给newCapacity
newCapacity = minCapacity;
/*判断新容量是否超过了 MAX_ARRAY_SIZE（一个常量，表示数组可以分配的最大容量）。
如果超过了，就需要调用 hugeCapacity(minCapacity) 方法来确定最终的容量。*/
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
/*创建一个新的数组，其大小为 newCapacity，并将现有数组的内容复制到新数组中。
然后将 elementData 引用更新为指向这个新的更大的数组。*/
elementData = Arrays.copyOf(elementData, newCapacity);
}
//
private static int hugeCapacity(int minCapacity) {
//判断输入是否合法
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
/*用于确定返回的容量值。如果 minCapacity 大于 MAX_ARRAY_SIZE（一个常量，大小为
Integer.MAX_VALUE - 8），则方法返回 Integer.MAX_VALUE，这是 int 类型可以表示的最大
值。如果 minCapacity 不大于 MAX_ARRAY_SIZE，则返回 MAX_ARRAY_SIZE。*/
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}3、ensureCapacityInternal(int minCapacity) 方法及其内部方法
//用于计算确保 ArrayList 可以容纳传入的 minCapacity 个元素所需的最小容量。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//判断 elementData 是否为默认的空数组，如果 elementData 是默认的空数组，
//则返回 DEFAULT_CAPACITY（默认容量，通常是10）和 minCapacity 中的较大值。
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//否则返回 minCapacity
return minCapacity;
}
//用于确保 ArrayList 的内部数组有足够的空间来容纳传入的 minCapacity 个元素。
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//用于确保 ArrayList 的内部数组至少有 minCapacity 的容量。
private void ensureExplicitCapacity(int minCapacity) {
//用于记录集合被修改次数的变量，每次修改集合（添加、删除元素等） 时都会增加
modCount++;
//判断当前数组容量是否满足所需的大小，不满足则进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}4、remove()方法
4.1remove(int index)；
删除指定下标的元素
public E remove(int index) {
//判断索引是否合法
rangeCheck(index);
//集合总修改次数加1
modCount++;
//获取并保存索引 index 处元素的值，以便稍后返回。
E oldValue = elementData(index);
//计算从被移除元素之后到数组末尾的元素数量。
int numMoved = size - index - 1;
//判断如果 numMoved 大于 0，说明被移除元素后面还有其他元素，需要将这些元素向前移动。
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将数组最后一个元素置空，并减小数组容量
elementData[--size] = null; // clear to let GC do its work
//返回被删除的值
return oldValue;
}4.2remove(Object o) ；
删除指定的元素
public boolean remove(Object o) {
//检查要移除的元素是否为 null
if (o == null) {
//遍历数组，如果找到 null 值，则调用 fastRemove(index) 方法移除该位置的元素。
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
}
/*如果要移除的元素不是 null，则使用 equals 方法来检查数组中的元素是否存在与要移除元素相等
的元素。如果找到则调用fastRemove()方法删除*/
else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
//没有找到指定元素则返回 false
return false;
}4.3fastRemove(int index)；
移除数组中指定索引位置的元素
private void fastRemove(int index) {
//对集合的操作次数加1
modCount++;
//计算从被移除元素之后到数组末尾的元素数量。
int numMoved = size - index - 1;
//判断如果 numMoved 大于 0，说明被移除元素后面还有其他元素，需要将这些元素向前移动。
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将数组最后一个元素置空，并减小数组容量
elementData[--size] = null; // clear to let GC do its work
}4.4removeRange(int fromIndex, int toIndex)；
用于移除列表中从 fromIndex（包含）到 toIndex（不包含）的元素。
protected void removeRange(int fromIndex, int toIndex) {
//对集合的操作次数加1
modCount++;
//从 toIndex 到数组末尾的元素数量，这些元素需要向前移动 toIndex - fromIndex个单位
int numMoved = size - toIndex;
//从 toIndex 开始的 numMoved 个元素复制到从 fromIndex 开始的位置
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
//计算移除元素后数组的新大小
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
//将被移除的元素位置置为 null，帮助垃圾回收器回收不再使用的对象。
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
//新数组的大小
size = newSize;
}4.5removeAll()；
用于移除列表中所有包含在指定集合 c 中的元素
//<?> 是一个通配符，表示集合可以包含任何类型的对象。
public boolean removeAll(Collection<?> c) {
//确保传入的集合 c 不是 null。如果是 null，将抛出一个 NullPointerException。
Objects.requireNonNull(c);
//实际执行移除操作的方法
return batchRemove(c, false);
}5、batchRemove(Collection<?> c, boolean complement)；
用于批量移除列表中的元素。 complement 参数的值决定是保留还是移除在指定集合 c 中的元素。
private boolean batchRemove(Collection<?> c, boolean complement) {
//将当前数组传给elementData 数组
final Object[] elementData = this.elementData;
// r 读取位置，w 写入位置
int r = 0, w = 0;
//标志变量，用于记录列表是否被修改
boolean modified = false;
//尝试执行以下操作，如果抛出异常，则直接执行 finally 块
try {
/*遍历所有元素，并检查当前元素是否应该被保留或移除。如果 complement 为 true，则保留
不在集合 c 中的元素；如果为 false，则保留在集合 c 中的元素。如果当前元素要被保留，则
将其复制到写入位置，并递增写入位置。*/
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 的位置不是最后一个元素的位置，说明还有元素未被复制进数组。
if (r != size) {
//将剩余元素复制进数组
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
/*如果写入位置 w 小于列表的大小，说明有元素被移除。这是就要清理剩余的元素，并更新列
表的大小和修改次数。*/
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
//将不需要的数组元素设置为空
elementData[i] = null;
//更新集合的修改次数
modCount += size - w;
//新数组的大小即为写入的数组元素个数
size = w;
//设置修改标志为 true，表示列表已被修改
modified = true;
}
}
//如果至少有一个元素被移除，则返回 true；否则返回 false。
return modified;
}6、rangeCheck(int index)和rangeCheckForAdd(int index)方法
//用于检查给定的索引是否在数组列表的有效范围内。
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//用于检查添加元素时索引是否有效。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}7、get(int index)；
从一个集合中获取并返回指定索引位置的元素。
public E get(int index) {
/*检查索引index是否在有效范围内。如果索引超出范围，rangeCheck方法将抛出一个IndexOutOfBoundsException异常。*/
rangeCheck(index);
return elementData(index);
}8、set(int index, E element);
将指定索引位置的元素替换为新的元素，并返回该索引位置原来的元素。
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}9、indexOf(Object o)；
用于在数组中查找并返回指定对象o的索引。如果数组中存在该对象，则返回第一个匹配项的索引；如果不存在，则返回-1。
public int indexOf(Object o) {
/*如果o是null，则遍历数组elementData，使用==运算符比较数组中的元素与null，因为null不能使
用equals方法进行比较。如果找到匹配的null值，则返回当前索引i。*/
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
}
/*如果o不是null，则遍历数组elementData，使用equals方法比较数组中的元素与o。
如果找到匹配的元素，则返回当前索引i。*/
else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}10、contains(Object o)；
检查一个集合是否包含指定的对象o。
public boolean contains(Object o) {
return indexOf(o) >= 0;
}11、isEmpty()；
用来判断数组是否为空
public boolean isEmpty() {
return size == 0;
}
扫一扫
476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
