ArrayList源码解读—Java8版本，2024年最新龙湖java面试简历经历

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

private void grow(int minCapacity) {

// 获取当前数组的容量

int oldCapacity = elementData.length;

// 扩容。新的容量=当前容量+当前容量/2.即将当前容量增加一半。

int newCapacity = oldCapacity + (oldCapacity >> 1);

//如果扩容后的容量还是小于想要的最小容量

if (newCapacity - minCapacity < 0)

//将扩容后的容量再次扩容为想要的最小容量

newCapacity = 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);

}

/**

• 进行大容量分配

*/

private static int hugeCapacity(int minCapacity) {

//如果minCapacity<0，抛出异常

if (minCapacity < 0) // overflow

throw new OutOfMemoryError();

//如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE

return (minCapacity > MAX_ARRAY_SIZE) ?

Integer.MAX_VALUE :

MAX_ARRAY_SIZE;

}

看完了代码，可以对扩容方法总结如下：

• 进行空间检查，决定是否进行扩容，以及确定最少需要的容量

• 如果确定扩容，就执行grow(int minCapacity)，minCapacity为最少需要的容量

• 第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础上增加一半。

• 第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。

• 对扩容后的容量进行判断，如果大于允许的最大容量MAX_ARRAY_SIZE，则将容量再次调整为MAX_ARRAY_SIZE。至此扩容操作结束。

6.4 add( int index, E element)

/**

• 在制定位置插入元素。当前位置的元素和index之后的元素向后移一位

• @param index 即将插入元素的位置

• @param element 即将插入的元素

• @throws IndexOutOfBoundsException 如果索引超出size

*/

public void add(int index, E element) {

//越界检查

rangeCheckForAdd(index);

//确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费

ensureCapacityInternal(size + 1); // Increments modCount!!

// 对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素位移一个位置

System.arraycopy(elementData, index, elementData, index + 1,size - index);

//将指定的index位置赋值为element

elementData[index] = element;

//实际容量+1

size++;

}

从源码中可以看到，add(E e)有三个步骤：

• 越界检查

• 空间检查，如果有需要进行扩容

• 插入元素

越界检查很简单

private void rangeCheckForAdd(int index) {

if (index > size || index < 0)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

空间检查和扩容的介绍在上面。

空间的问题解决后，插入过程就显得非常简单。

add(int index, E e)需要先对元素进行移动，然后完成插入操作，也就意味着该方法有着线性的时间复杂度，即O(n)。

6.5 remove( int index)

/**

• 删除list中位置为指定索引index的元素

• 索引之后的元素向左移一位

• @param index 被删除元素的索引

• @return 被删除的元素

• @throws IndexOutOfBoundsException 如果参数指定索引index>=size，抛出一个越界异常

*/

public E remove(int index) {

//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常

rangeCheck(index);

//结构性修改次数+1

modCount++;

//记录索引为inde处的元素

E oldValue = elementData(index);

// 删除指定元素后，需要左移的元素个数

int numMoved = size - index - 1;

//如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）

if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,

numMoved);

// size减一，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值

elementData[–size] = null; // clear to let GC do its work

//返回被删除的元素

return oldValue;

}

/**

• 越界检查。

• 检查给出的索引index是否越界。

• 如果越界，抛出运行时异常。

• 这个方法并不检查index是否合法。比如是否为负数。

• 如果给出的索引index>=size，抛出一个越界异常

*/

private void rangeCheck(int index) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

看完代码后，可以将ArrayList删除指定索引的元素的步骤总结为：

• 检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常

• 将索引大于index的元素左移一位（左移后，该删除的元素就被覆盖了，相当于被删除了）。

• 将索引为size-1处的元素置为null（为了让GC起作用）。

注意：为了让GC起作用，必须显式的为最后一个位置赋null值。上面代码中如果不手动赋null值，除非对应的位置被其他元素覆盖，否则原来的对象就一直不会被回收。

6.6 set( int index, E element)

/**

• 替换指定索引的元素

• @param 被替换元素的索引

• @param element 即将替换到指定索引的元素

• @return 返回被替换的元素

• @throws IndexOutOfBoundsException 如果参数指定索引index>=size，抛出一个越界异常

*/

public E set(int index, E element) {

//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常

rangeCheck(index);

//记录被替换的元素

E oldValue = elementData(index);

//替换元素

elementData[index] = element;

//返回被替换的元素

return oldValue;

}

这里可以看到modCount的用处，当modCount发生改变后，立刻抛出ConcurrentModificationException异常。通过之前的分析可以知道当列表内容被修改时modCount会增加。也就是说如果在遍历ArrayList的过程中有其他线程修改了ArrayList，那么将抛出ConcurrentModificationException异常

6.7 indexOf(Object o)

indexOf(Object o)方法的作用是从头开始查找与指定元素相等的元素，如果找到，则返回找到的元素在元素数组中的下标，如果没有找到返回-1。与该方法类似的是lastIndexOf(Object o)方法，该方法的作用是从尾部开始查找与指定元素相等的元素。

查看该方法的源码可知，该方法从需要查找的元素是否为空的角度分为两种情况分别讨论。这也意味着该方法的参数可以是null元素，也意味着ArrayList集合中能够保存null元素。方法实现的逻辑也比较简单，直接循环遍历元素数组，通过equals方法来判断对象是否相同，相同就返回下标，找不到就返回-1。这也解释了为什么要把情况分为需要查找的对象是否为空两种情况讨论，不然的话空对象调用equals方法则会产生空指针异常。

// 从首开始查找数组里面是否存在指定元素

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;

}

6.8 forEach(Consumer<? super E> action)

遍历列表 ，这里我们先来看一下源码是怎么写的：

/**

• The number of times this list has been structurally modified.

• Structural modifications are those that change the size of the

• list, or otherwise perturb it in such a fashion that iterations in

• progress may yield incorrect results.

• This field is used by the iterator and list iterator implementation

• returned by the {@code iterator} and {@code listIterator} methods.

• If the value of this field changes unexpectedly, the iterator (or list

• iterator) will throw a {@code ConcurrentModificationException} in

• response to the {@code next}, {@code remove}, {@code previous},

• {@code set} or {@code add} operations. This provides

• fail-fast behavior, rather than non-deterministic behavior in

• the face of concurrent modification during iteration.

• Use of this field by subclasses is optional. If a subclass

• wishes to provide fail-fast iterators (and list iterators), then it

• merely has to increment this field in its {@code add(int, E)} and

• {@code remove(int)} methods (and any other methods that it overrides

• that result in structural modifications to the list). A single call to

• {@code add(int, E)} or {@code remove(int)} must add no more than

• one to this field, or the iterators (and list iterators) will throw

• bogus {@code ConcurrentModificationExceptions}. If an implementation

• does not wish to provide fail-fast iterators, this field may be

• ignored.

*/

protected transient int modCount = 0;//操作数，since abstract AbstractList.java

@Override

public void forEach(Consumer<? super E> action) {

// 确保不为空

Objects.requireNonNull(action);

final int expectedModCount = modCount;

@SuppressWarnings(“unchecked”)

final E[] elementData = (E[]) this.elementData;

final int size = this.size;

for (int i=0; modCount == expectedModCount && i < size; i++) {

action.accept(elementData[i]);

}

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

}

/**

• Checks that the specified object reference is not {@code null}. This

• method is designed primarily for doing parameter validation in methods

• and constructors, as demonstrated below:

• public Foo(Bar bar) {

• this.bar = Objects.requireNonNull(bar);
  

• }

• @param obj the object reference to check for nullity

• @param the type of the reference

• @return {@code obj} if not {@code null}

• @throws NullPointerException if {@code obj} is {@code null}

*/

public static T requireNonNull(T obj) {//since final class Objects.java

if (obj == null)

throw new NullPointerException();

return obj;

}

6.9 clear()方法

/**

• Removes all of the elements from this list. The list will

• be empty after this call returns.

从列表中删除所有元素。该调用返回后，列表将为空。

*/

public void clear() {

modCount++;

// clear to let GC do its work

for (int i = 0; i < size; i++)

elementData[i] = null;

size = 0;

}

这里我们做一个小demo：

package com.uncle;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.HashMap;

public class Main {

public static void main(String[] args) throws Exception {

HashMap hashMap = new HashMap();

ArrayList arrayList = new ArrayList();

Main main = new Main();

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

arrayList.add(main);

Class<? extends ArrayList> aClass = arrayList.getClass();

Field elementData = aClass.getDeclaredField(“elementData”);

elementData.setAccessible(true);

Object[] objects = (Object[]) elementData.get(arrayList);

arrayList.clear();

System.out.println(objects.length);

System.out.println(arrayList.size());

}

}

显然，容量虽然扩容了，但是里面的有效元素全部清空了。

七、ArrayList与迭代器模式

---

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象中的各个元素，而不用暴露这个对象的内部表示。

在Java中，ArrayList的迭代器有两种：Iterator和ListIterator。

7.1 Iterator

迭代器是一个用来遍历并选择序列中的对象。Java的Iterator的只能单向移动。

案例

在写如何实现之前，先看一个使用迭代器Iterator小例子：

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class Test {

@org.junit.Test

public void test() {

List list = new ArrayList<>();

list.add(“1”);

list.add(“2”);

list.add(“3”);

list.add(“4”);

Iterator iterator = list.iterator();

while (iterator.hasNext()) {

String str = (String) iterator.next();

System.out.println(str);

iterator.remove();

}

System.out.println(list.size());

}

}

运行结果

1

2

3

4

0

方法

• iterator()，list.iterator()用来从容器对象中返回一个指向list开始处的迭代器。

• next(),获取序列中的下个元素。

• hasNext(),检查序列中向下是否还有元素。

• remove(),将迭代器最近返回的一个元素删除。这也意味着调用remove()前需要先调用next()。

实现

迭代器模式中有四个角色：

• 抽象聚合类Aggregate。在ArrayList的Iterator迭代器实现中，没有抽象聚合类。虽然它实现了AbstractList，实现了List，但它向外部提供的创建迭代器的方法iterator()是它自己的。

• 具体聚合类ConcreteAggregate。在ArrayList的Iterator迭代器实现中，指的是ArrayList。

• 抽象迭代器Iterator。在ArrayList的Iterator迭代器实现中，指的是Iterator接口。

• 具体迭代器ConcreteIterator。在ArrayList中的Iterator迭代器实现中，指的是Itr。

ArrayList代码片段

public class ArrayList

{

/**

• 保存添加到ArrayList中的元素。

• ArrayList的容量就是该数组的长度。

• 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。

• 被标记为transient，在对象被序列化的时候不会被序列化。

*/

transient Object[] elementData;

// ArrayList的实际大小（数组包含的元素个数）。

private int size;

/**

• 返回一个用来遍历ArrayList元素的Iterator迭代器

*/

public Iterator iterator() {

return new Itr();

}

/**

• AbstractList.Itr的最优化的版本

*/

private class Itr implements Iterator {

int cursor; // 下一个要返回的元素的索引

int lastRet = -1; // 最近的被返回的元素的索引; 如果没有返回-1。

int expectedModCount = modCount;

/**

• 判断是否有下一个元素

*/

public boolean hasNext() {

//如果下一个要返回的元素的索引不等于ArrayList的实际大小，则返回false

return cursor != size;

}

/**

• 返回下一个元素

*/

@SuppressWarnings(“unchecked”)

public E next() {

checkForComodification();

int i = cursor;

if (i >= size)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i + 1;

return (E) elementData[lastRet = i];

}

/**

• 删除最近的一个被返回的元素

*/

public void remove() {

if (lastRet < 0)

throw new IllegalStateException();

checkForComodification();

try {

ArrayList.this.remove(lastRet);

cursor = lastRet;

lastRet = -1;

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

@Override

@SuppressWarnings(“unchecked”)

public void forEachRemaining(Consumer<? super E> consumer) {

Objects.requireNonNull(consumer);

final int size = ArrayList.this.size;

int i = cursor;

if (i >= size) {

return;

}

final Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length) {

throw new ConcurrentModificationException();

}

while (i != size && modCount == expectedModCount) {

consumer.accept((E) elementData[i++]);

}

// update once at end of iteration to reduce heap write traffic

cursor = i;

lastRet = i - 1;

checkForComodification();

}

final void checkForComodification() {

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

}

}

Iterator

import java.util.function.Consumer;

public interface Iterator {

boolean hasNext();

E next();

default void remove() {

throw new UnsupportedOperationException(“remove”);

}

default void forEachRemaining(Consumer<? super E> action) {

Objects.requireNonNull(action);

while (hasNext())

action.accept(next());

}

}

Itr.java

ArrayList的内部类

7.2 ListIterator

ListIterator是一个更加强大的Iterator的子类型。它只能用于各种List类的访问。它最大的优点是可以双向移动。它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引，并且可以使用set()方法替换它访问过的最后一个元素。

案例

在写如何实现之前，先看一个使用列表迭代器ListIterator的小例子：

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

public class Test {

@org.junit.Test

public void test() {

List list = new ArrayList<>();

list.add(“0”);

list.add(“1”);

list.add(“2”);

list.add(“3”);

ListIterator iterator = list.listIterator();

System.out.println(“--------------------向下遍历--------------------”);

while (iterator.hasNext()) {

int nextIndex = iterator.nextIndex();

String next = (String) iterator.next();

//int previousIndex = iterator.previousIndex();

System.out.println(“当前元素：”+next+“，当前元素索引：”+nextIndex/+“，前一个元素的索引”+previousIndex/);

}

System.out.println(“--------------------向上遍历--------------------”);

while (iterator.hasPrevious()) {

int previousIndex = iterator.previousIndex();

String previous = (String) iterator.previous();

System.out.println(“当前元素：”+previous+“，当前元素索引：”+previousIndex);

}

System.out.println(“-----------测试set()和listIterator(n)----------”);

System.out.println(list);

iterator = list.listIterator(3);

while(iterator.hasNext()){

iterator.next();

iterator.set(“5”);

}

System.out.println(list);

}

}

运行结果

-------向下遍历-------

当前元素：0，当前元素索引：0

当前元素：1，当前元素索引：1

当前元素：2，当前元素索引：2

当前元素：3，当前元素索引：3

-------向上遍历-------

当前元素：3，当前元素索引：3

当前元素：2，当前元素索引：2

当前元素：1，当前元素索引：1

当前元素：0，当前元素索引：0

-------测试set()和listIterator(n)-------

[0, 1, 2, 3]

[0, 1, 2, 5]

方法

• listIterator()，list.iterator()用来从容器对象中返回一个指向list开始处的迭代器。

• listIterator(n)，list.iterator()用来从容器对象中返回一个指向列表索引为n的迭代器。

• next(),获取序列中的下个元素，运行后索引+1。

• previous(),获取序列中的上个元素，运行后索引-1。

• nextIndex,获取序列中的下个元素的索引。

• previousIndex,获取序列中的下个元素的索引。

• hasNext(),检查序列中向下是否还有元素。

• hasPrevious(),检查序列中向上是否还有元素。

• remove(),从列表中删除next()或previous()返回的最后一个元素。这也意味着调用remove()前需要先调用next()或者previous()。

• add(E e): 将指定的元素插入列表，插入位置为迭代器当前位置之前。

• set(E e)：从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e。

实现

迭代器模式中有四个角色：

• 抽象聚合类Aggregate。在ArrayList的ListIterator迭代器实现中，没有抽象聚合类。虽然它实现了AbstractList，实现了List，但它向外部提供的创建迭代器的方法listIterator()是它自己的。

• 具体聚合类ConcreteAggregate。在ArrayList的ListIterator迭代器实现中，指的是ArrayList。

• 抽象迭代器Iterator。在ArrayList的ListIterator迭代器实现中，指的是ListIterator。

• 具体迭代器ConcreteIterator。在ArrayList中的ListIterator迭代器实现中，指的是ListItr。

ArrayList代码片段

public class ArrayList

{

/**

• 保存添加到ArrayList中的元素。

• ArrayList的容量就是该数组的长度。

• 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。

• 被标记为transient，在对象被序列化的时候不会被序列化。

*/

transient Object[] elementData;

// ArrayList的实际大小（数组包含的元素个数）。

private int size;

/**

• 返回一个一开始就指向列表索引为index的元素处的ListIterator

• @throws IndexOutOfBoundsException

*/

public ListIterator listIterator(int index) {

if (index < 0 || index > size)

throw new IndexOutOfBoundsException("Index: "+index);

return new ListItr(index);

}

/**

• 返回一个一开始就指向列表索引为0的元素处的ListIterator

• @see #listIterator(int)

*/

public ListIterator listIterator() {

return new ListItr(0);

}

/**

• AbstractList.ListItr的最优化版本

*/

private class ListItr extends Itr implements ListIterator {

//用来从list中返回一个指向list索引为index的元素处的迭代器

ListItr(int index) {

super();

cursor = index;

}

//获取list中的上个元素

public boolean hasPrevious() {

return cursor != 0;

}

//获取list中的下个元素的索引

public int nextIndex() {

return cursor;

}

//获取list中的上个元素的索引

public int previousIndex() {

return cursor - 1;

}

//获取list中的上个元素

@SuppressWarnings(“unchecked”)

public E previous() {

checkForComodification();

int i = cursor - 1;

if (i < 0)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i;

return (E) elementData[lastRet = i];

}

//从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e

public void set(E e) {

if (lastRet < 0)

throw new IllegalStateException();

checkForComodification();

try {

ArrayList.this.set(lastRet, e);

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

//将指定的元素插入列表，插入位置为迭代器当前位置之前。

public void add(E e) {

checkForComodification();

try {

int i = cursor;

ArrayList.this.add(i, e);

cursor = i + 1;

lastRet = -1;

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

}

}

Iterator

import java.util.function.Consumer;

public interface Iterator {

boolean hasNext();

E next();

default void remove() {

throw new UnsupportedOperationException(“remove”);

}

default void forEachRemaining(Consumer<? super E> action) {

Objects.requireNonNull(action);

while (hasNext())

action.accept(next());

}

}

ListItr.java

ArrayList的内部类。

八、阿里面试实战

---

7.1 ArrayList如何删除指定元素？

这是一个很麻烦的面试题，很考验对源码的认识和理解，我们来慢慢的剖析一下。

为了大家能够更好的理解ArrayList，以及这道面试题，推荐大家看一下这篇文章：

ArrayList与迭代器模式

如果使用常规的思想：

public class TestListMain {

public static void main(String[] args) {

List result = new ArrayList<>();

result.add(“a”);

result.add(“b”);

result.add(“c”);

result.add(“d”);

for (String s : result) {

if (“b”.equals(s)) {

result.remove(“b”);

}

}

}

}

可是这样就会抛出异常：

既然从源代码分析不出来，我们就看下源代码编译后的class文件中的内容是怎样的吧，毕竟class文件才是JVM真正执行的代码，不看不知道，一看吓一跳，JDK原来是这么玩的。原来如此，我们原始代码中的for-each语句，编译后的实际是以迭代器来代替执行的。

public class TestListMain {

public TestListMain() {

}

public static void main(String[] args) {

List result = new ArrayList();

result.add(“a”);

result.add(“b”);

result.add(“c”);

result.add(“d”);

//创建迭代器

Iterator var2 = result.iterator();

while(var2.hasNext()) {

String s = (String)var2.next();

if (“b”.equals(s)) {

result.remove(“b”);

}

}

}

}

通过ArrayList创建的Itr这个内部类迭代器，于是for-each循环就转化成了迭代器加while循环的方式，原来看上去的for-each循环被挂羊头卖狗肉了。

public Iterator iterator() {

return new Itr();

}

Itr这个内部类迭代器，通过判断hasNext()来判断迭代器是否有内容，而next()方法则获取迭代器中的内容。

private class Itr implements Iterator {

int cursor; // index of next element to return

int lastRet = -1; // index of last element returned; -1 if no such

int expectedModCount = modCount;

Itr() {}

public boolean hasNext() {

return cursor != size;

}

@SuppressWarnings(“unchecked”)

public E next() {

checkForComodification();

int i = cursor;

if (i >= size)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i + 1;

return (E) elementData[lastRet = i];

}

…

}

大致的过程如下所示：

真正抛异常的地方是这个检测方法， 当modCount与expectedModCount不相等的时候直接抛出异常了。那我们要看下modCount以及expectedModCount分别是什么。这里的modCount代表ArrayList的修改次数，而expectedModCount代表的是迭代器的修改次数，在创建Itr迭代器的时候，将modCount赋值给了expectedModCount，因此在本例中一开始modCount和expectedModCount都是4（添加了四次String元素）。但是在获取到b元素之后，ArrayList进行了remove操作，因此modCount就累加为5了。因此在进行检查的时候就出现了不一致，最终导致了异常的产生。到此我们找到了抛异常的原因，循环使用迭代器进行循环，但是操作元素却是使用的ArrayList操作，因此迭代器在循环的时候发现元素被修改了所以抛出异常。

我们再来思考下，为什么要有这个检测呢？这个异常到底起到什么作用呢？我们先来开下ConcurrentModificationException的注释是怎么描述的。简单理解就是不允许一个线程在修改集合，另一个线程在集合基础之上进行迭代。一旦检测到了这种情况就会通过fast-fail机制，抛出异常，防止后面的不可知状况。

/**

---

• For example, it is not generally permissible for one thread to modify a Collection

• while another thread is iterating over it. In general, the results of the

• iteration are undefined under these circumstances. Some Iterator

• implementations (including those of all the general purpose collection implementations

• provided by the JRE) may choose to throw this exception if this behavior is

• detected. Iterators that do this are known as fail-fast iterators,

• as they fail quickly and cleanly, rather that risking arbitrary,

• non-deterministic behavior at an undetermined time in the future.

---

**/

public class ConcurrentModificationException extends RuntimeException {

…

}

回顾整个过程

如何正确的删除

既然抛异常的原因是循环使用了迭代器，而删除使用ArrayList导致检测不通过。那么我们就循环使用迭代器，删除也是用迭代器，这样就可以保证一致了。

public class TestListMain {

public static void main(String[] args) {

List result = new ArrayList<>();

result.add(“a”);

result.add(“b”);

result.add(“c”);

result.add(“d”);

Iterator iterator = list.iterator();

while (iterator .hasNext()) {

String str = iterator.next();

if (“b”.equals(str)) {

iterator.remove();

}

}

}

7.3 为啥线程不安全还使用ArrayList呢？

因为在我们正常得使用场景中，都是用来查询的，不会涉及太频繁的增删，如果涉及到频繁的增删，可以使用LinkedList，如果需要线程安全的就是可以使用Vector，CopyOrWriteArrayList

7.4 1.7和1.8版本初始化的区别

1.7的时候是初始化就创建一个容量为10的数组，1.8后是初始化先创建一个空数组，第一次add时才扩容为10

7.5 ArrayList在增删的时候是怎么做的？（为什么慢）

ArrayList有指定index（索引下标）新增，也有尾部新增，但是都有校验长度的判断ensureCapacityInternal，就是说如果⻓度不够，是需要扩容的。

在扩容的时候，1.7是取余，1.8是位运算，右移⼀位，其实就是除以2这个操作。

//尾插add方法

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!

elementData[size++] = e;

return true;

}

//index(索引)插入，指定位置新增的时候，在校验之后的操作很简单，就是数组的copy

public void add(int index, E element) {

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1); // Increments modCount!!

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

elementData[index] = element;

size++;

}

//真正扩容

private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + (oldCapacity >> 1);

if (newCapacity - minCapacity < 0)

newCapacity = 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);

}

//删除

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; // clear to let GC do its work

return oldValue;

}

总结：总的来说，不论是删除还是新增，其实本质上都是移动位置，当指定位置新增的时候，新增的索空出，后面向后移一位，然后赋值，当删除时，也是一样，将要删除的索引下标的值置为null。

7.6 ArrayList是线程安全的么？

不是，可以用Vector,Collections.synchronizedList(),原理都是給方法套个synchronized，

CopyOnWriteArrayList

7.7 ArrayList⽤来做队列合适么？

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

大厂面试场景

知识点总结

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

entData[size++] = e;

return true;

}

//index(索引)插入，指定位置新增的时候，在校验之后的操作很简单，就是数组的copy

public void add(int index, E element) {

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1); // Increments modCount!!

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

elementData[index] = element;

size++;

}

//真正扩容

private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + (oldCapacity >> 1);

if (newCapacity - minCapacity < 0)

newCapacity = 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);

}

//删除

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; // clear to let GC do its work

return oldValue;

}

总结：总的来说，不论是删除还是新增，其实本质上都是移动位置，当指定位置新增的时候，新增的索空出，后面向后移一位，然后赋值，当删除时，也是一样，将要删除的索引下标的值置为null。

7.6 ArrayList是线程安全的么？

不是，可以用Vector,Collections.synchronizedList(),原理都是給方法套个synchronized，

CopyOnWriteArrayList

7.7 ArrayList⽤来做队列合适么？

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

[外链图片转存中…(img-aZwUGHdH-1713596144675)]

大厂面试场景

[外链图片转存中…(img-zASuxvc4-1713596144675)]

知识点总结

[外链图片转存中…(img-Uv2k2ZYs-1713596144676)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-Dhtrt1de-1713596144677)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！