以下内容为从网上摘抄整理而来,仅用于本人知识积累
一、简介
ArrayList就是数组列表,主要用来装载数据,当我们装载的是基本类型的数据int,long,boolean,short,byte…的时候我们只能存储他们对应的包装类,它的主要底层实现是数组Object[] elementData。
与它类似的是LinkedList,和LinkedList相比,它的查找和访问元素的速度较快,但新增,删除的速度较慢。
ArrayList继承于 AbstractList ,实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
}
- RandomAccess 是一个标志接口,表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中,我们可以通过元素的序号快速获取元素对象,这就是快速随机访问。
- ArrayList 实现了 Cloneable 接口 ,即覆盖了函数clone(),能被克隆。
- ArrayList 实现了 java.io.Serializable 接口,这意味着ArrayList支持序列化,能通过序列化去传输。
小结:ArrayList底层是用数组实现的存储。集合中允许 null
的存在
特点:查询效率高,增删效率低,线程不安全。使用频率很高。
二、属性
// 序列化版本UID
private static final long
serialVersionUID = 8683452581122892189L;
/**
* 默认的初始容量
*/
private static final int
DEFAULT_CAPACITY = 10;
/**
* 用于空实例的共享空数组实例
* new ArrayList(0);
*/
private static final Object[]
EMPTY_ELEMENTDATA = {};
/**
* 用于提供默认大小的实例的共享空数组实例
* new ArrayList();
*/
private static final Object[]
DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存储ArrayList元素的数组缓冲区
* ArrayList的容量,是数组的长度
*
* non-private to simplify nested class access
*/
transient Object[] elementData;
/**
* ArrayList中元素的数量
*/
private int size;
三、构造方法
1. 带初始容量的构造方法
/**
* 带一个初始容量参数的构造方法
*
* @param initialCapacity 初始容量
* @throws 如果初始容量非法就抛出
* IllegalArgumentException
*/
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);
}
}
- 如果initialCapacity > 0,就创建一个新的长度是initialCapacity的数组
- 如果initialCapacity == 0,就使用EMPTY_ELEMENTDATA
- 其他情况,initialCapacity不合法,抛出异常
2. 无参构造方法
/**
* 无参构造方法 将elementData 赋值为
* DEFAULTCAPACITY_EMPTY_ELEMENTDATA
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
以无参数构造方法创建 ArrayList 时,实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时,才真正分配容量。即向数组中添加第一个元素时,数组容量扩为 10。
补充:JDK7 new无参构造的
ArrayList
对象时,直接创建了长度是10的Object[]
数组elementData
。jdk7中的ArrayList
的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList
的对象的创建类似于单例的懒汉式。JDK8的内存优化也值得我们在平时开发中学习。
3.带一个集合参数的构造方法
/**
* 带一个集合参数的构造方法
*
* @param c 集合,代表集合中的元素会被放到list中
* @throws 如果集合为空,抛出NullPointerException
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
// 如果 size != 0
if ((size = elementData.length) != 0) {
// c.toArray 可能不正确的,不返回 Object[]
// https://bugs.openjdk.java.net/browse/JDK-6260652
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// size == 0
// 将EMPTY_ELEMENTDATA 赋值给 elementData
this.elementData = EMPTY_ELEMENTDATA;
}
}
- 使用将集合转换为数组的方法
- 为了防止c.toArray()方法不正确的执行,导致没有返回Object[],特殊做了处理
- 如果数组大小等于0,则使用 EMPTY_ELEMENTDATA
1. 什么情况下 c.toArray()
会不返回 Object[]
呢?
public static void main(String[] args) {
List<String> list = new ArrayList<>(Arrays.asList("list"));
// class java.util.ArrayList
System.out.println(list.getClass());
Object[] listArray = list.toArray();
// class [Ljava.lang.Object;
System.out.println(listArray.getClass());
listArray[0] = new Object();
System.out.println();
List<String> asList = Arrays.asList("asList");
// class java.util.Arrays$ArrayList
System.out.println(asList.getClass());
Object[] asListArray = asList.toArray();
// class [Ljava.lang.String;
System.out.println(asListArray.getClass());
// java.lang.ArrayStoreException
asListArray[0] = new Object();
}
我们通过这个例子可以看出来,java.util.ArrayList.toArray()
方法会返回 Object[]
没有问题。而java.util.Arrays
的私有内部类 ArrayList
的 toArray()
方法可能不返回 Object[]
。
2. 为什么会这样?
我们看ArrayList的toArray()方法源码:
public Object[] toArray() {
// ArrayLisy中 elementData是这样定义的
// transient Object[] elementData;
return Arrays.copyOf(elementData, size);
}
使用了 Arrays.copyOf()
方法:
public static <T> T[] copyOf(T[] original, int newLength) {
// original.getClass() 是 class [Ljava.lang.Object
return (T[]) copyOf(original, newLength, original.getClass());
}
copyOf()
的具体实现:
public static <T,U> T[] copyOf(U[] original,
int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
/**
* 如果newType是Object[] copy 数组 类型就是 Object
* 否则就是 newType 类型
*/
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;
}
我们知道 ArrayList
中 elementData
就是 Object[]
类型,所以 ArrayList
的 toArray()
方法必然会返回 Object[]
。
我们再看一下 java.util.Arrays
的内部 ArrayList
源码(截取的部分源码):
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable {
// 存储元素的数组
private final E[] a;
ArrayList(E[] array) {
// 直接把接收的数组 赋值 给 a
a = Objects.requireNonNull(array);
}
/**
* obj 为空抛出异常
* 不为空 返回 obj
*/
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
@Override
public Object[] toArray() {
// 返回 a 的克隆对象
return a.clone();
}
}
这是 Arrays.asList()
方法源码
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
不难看出来 java.util.Arrays
的内部 ArrayList
的 toArray()
方法,是构造方法接收什么类型的数组,就返回什么类型的数组。
所以,在我们上面的例子中,实际上返回的是 String
类型的数组,再将其中的元素赋值成 Object
类型的,自然报错。
四、插入方法(JDK8)
1. 在列表最后添加指定元素
/**
* 在列表最后添加指定元素
*
* @param e 要添加的指定元素
* @return true
*/
public boolean add(E e) {
// 增加 modCount !!
ensureCapacityInternal(size + 1);
//这里看到ArrayList添加元素的实质就相当于为数组赋值
elementData[size++] = e;
return true;
}
在父类 AbstractList
上,定义了 modCount
属性,用于记录数组修改的次数。
注意 :JDK11 移除了
ensureCapacityInternal()
和ensureExplicitCapacity()
方法public boolean add(E e) { modCount++; add(e, elementData, size); return true; }
2. 在指定位置添加指定元素
/**
* 在指定位置添加指定元素
* 如果指定位置已经有元素,就将该元素和随后的元素移动到右面一位
*
* @param index 待插入元素的下标
* @param element 待插入的元素
* @throws 可能抛出 IndexOutOfBoundsException
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
// 增加 modCount !!
ensureCapacityInternal(size + 1);
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}
3. 插入方法调用的其他私有方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* 计算容量
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取默认的容量和传入参数的较大值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
当要 add 进第 1 个元素时,minCapacity 为 1,在 Math.max()方法比较后,minCapacity 为 10。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//调用grow方法进行扩容,调用此方法代表已经开始扩容了
grow(minCapacity);
}
我们来仔细分析一下:
- 当我们要 add 进第 1 个元素到 ArrayList 时,elementData.length 为 0 (因为还是一个空的 list),因为执行了
ensureCapacityInternal()
方法 ,所以 minCapacity 此时为 10。此时,minCapacity - elementData.length > 0
成立,所以会进入grow(minCapacity)
方法。- 当 add 第 2 个元素时,minCapacity 为 2,此时 elementData.length(容量)在添加第一个元素后扩容成 10 了。此时,
minCapacity - elementData.length > 0
不成立,所以不会进入 (执行)grow(minCapacity)
方法。- 添加第 3、4···到第 10 个元素时,依然不会执行 grow 方法,数组容量都为 10。
直到添加第 11 个元素,minCapacity(为 11)比 elementData.length(为 10)要大。进入 grow 方法进行扩容。
五、扩容方法 grow()
1. grow()
/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* ArrayList扩容的核心方法。
*/
private void grow(int minCapacity) {
// oldCapacity为旧容量,newCapacity为新容量
int oldCapacity = elementData.length;
//将oldCapacity 右移一位,其效果相当于oldCapacity /2,
//我们知道位运算的速度远远快于整除运算,整句运算式的结果就是将新容量更新为旧容量的1.5倍,
int newCapacity = oldCapacity + (oldCapacity >> 1);
//然后检查新容量是否大于最小需要容量,若还是小于最小需要容量,那么就把最小需要容量当作数组的新容量,
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE,
//如果minCapacity大于最大容量,则新容量则为`Integer.MAX_VALUE`,否则,新容量大小则为 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);
}
int newCapacity = oldCapacity + (oldCapacity >> 1)
,所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右(oldCapacity 为偶数就是 1.5 倍,否则是 1.5 倍左右)! 奇偶不同,比如 :10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.
我们再来通过例子探究一下
grow()
方法:
- 当 add 第 1 个元素时,oldCapacity 为 0,经比较后第一个 if 判断成立,newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立,即 newCapacity 不比 MAX_ARRAY_SIZE 大,则不会进入
hugeCapacity
方法。数组容量为 10,add 方法中 return true,size 增为 1。- 当 add 第 11 个元素进入 grow 方法时,newCapacity 为 15,比 minCapacity(为 11)大,第一个 if 判断不成立。新容量没有大于数组最大 size,不会进入 hugeCapacity 方法。数组容量扩为 15,add 方法中 return true,size 增为 11。
- 以此类推······
这里补充一点比较重要,但是容易被忽视掉的知识点:
- java 中的 length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.
- java 中的 length() 方法是针对字符串说的,如果想看这个字符串的长度则用到 length() 这个方法.
- java 中的 size() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
2.hugeCapacity()
从上面 grow()
方法源码我们知道: 如果新容量大于 MAX_ARRAY_SIZE
,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE,如果 minCapacity 大于最大容量,则新容量则为Integer.MAX_VALUE
,否则,新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8
。
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作为新数组的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
3. System.arraycopy()
和 Arrays.copyOf()
方法
阅读源码的话,我们就会发现 ArrayList 中大量调用了这两个方法。比如:上面讲的扩容操作以及 add(int index, E element)
、toArray()
等方法中都用到了该方法!
1. System.arraycopy()
方法
/**
* 在此列表中的指定位置插入指定的元素。
*先调用 rangeCheckForAdd 对index进行界限检查;然后调用 ensureCapacityInternal 方法保证capacity足够大;
*再将从index开始之后的所有成员后移一个位置;将element插入index位置;最后size加1。
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//arraycopy()方法实现数组自己复制自己
//elementData:源数组;index:源数组中的起始位置;elementData:目标数组;index + 1:目标数组中的起始位置; size - index:要复制的数组元素的数量;
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}
我们写一个简单的方法测试以下:
public class ArraycopyTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = new int[10];
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
System.arraycopy(a, 2, a, 3, 3);
a[2]=99;
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
}
结果:
0 1 99 2 3 0 0 0 0 0
2. Arrays.copyOf()
方法
/**
以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素); 返回的数组的运行时类型是指定数组的运行时类型。
*/
public Object[] toArray() {
//elementData:要复制的数组;size:要复制的长度
return Arrays.copyOf(elementData, size);
}
个人觉得使用 Arrays.copyOf()
方法主要是为了给原有数组扩容,测试代码如下:
public class ArrayscopyOfTest {
public static void main(String[] args) {
int[] a = new int[3];
a[0] = 0;
a[1] = 1;
a[2] = 2;
int[] b = Arrays.copyOf(a, 10);
System.out.println("b.length"+b.length);
}
}
结果:
10
3. 两者的区别和联系
联系:
看两者源代码可以发现 copyOf()
内部实际调用了 System.arraycopy()
方法
区别:
arraycopy()
需要目标数组,将原数组拷贝到你自己定义的数组里或者原数组,而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf()
是系统自动在内部新建一个数组,并返回该数组。
4. ensureCapacity
方法
ArrayList 源码中有一个 ensureCapacity
方法不知道大家注意到没有,这个方法 ArrayList 内部没有被调用过,所以很显然是提供给用户调用的,那么这个方法有什么作用呢?
/**
如有必要,增加此 ArrayList 实例的容量,以确保它至少可以容纳由minimum capacity参数指定的元素数。
*
* @param minCapacity 所需的最小容量
*/
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 大量元素之前用 ensureCapacity
方法,以减少增量重新分配的次数
我们通过下面的代码实际测试以下这个方法的效果:
public class EnsureCapacityTest {
public static void main(String[] args) {
ArrayList<Object> list = new ArrayList<Object>();
final int N = 10000000;
long startTime = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
list.add(i);
}
long endTime = System.currentTimeMillis();
System.out.println("使用ensureCapacity方法前:"+(endTime - startTime));
}
}
运行结果:
使用ensureCapacity方法前:2158
public class EnsureCapacityTest {
public static void main(String[] args) {
ArrayList<Object> list = new ArrayList<Object>();
final int N = 10000000;
list = new ArrayList<Object>();
long startTime1 = System.currentTimeMillis();
list.ensureCapacity(N);
for (int i = 0; i < N; i++) {
list.add(i);
}
long endTime1 = System.currentTimeMillis();
System.out.println("使用ensureCapacity方法后:"+(endTime1 - startTime1));
}
}
运行结果:
使用ensureCapacity方法前:1773
通过运行结果,我们可以看出向 ArrayList 添加大量元素之前最好先使用 ensureCapacity
方法,以减少增量重新分配的次数。
六、移除方法
1. 移除指定下标元素方法
/**
* 移除列表中指定下标位置的元素
* 将所有的后续元素,向左移动
*
* @param 要移除的指定下标
* @return 返回被移除的元素
* @throws 下标越界会抛出IndexOutOfBoundsException
*/
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);
// 将引用置空,让GC回收
elementData[--size] = null;
return oldValue;
}
2. 移除指定元素方法
/**
* 移除第一个在列表中出现的指定元素
* 如果存在,移除返回true
* 否则,返回false
*
* @param o 指定元素
*/
public boolean remove(Object o) {
if (o == 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;
}
移除方法名字、参数的个数都一样,使用的时候要注意。
3. 私有移除方法
/*
* 私有的 移除 方法 跳过边界检查且不返回移除的元素
*/
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 将引用置空,让GC回收
elementData[--size] = null;
}
七、查找方法
1. 查找指定元素的所在位置
/**
* 返回指定元素第一次出现的下标
* 如果不存在该元素,返回 -1
* 如果 o ==null 会特殊处理
*/
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;
}
2. 查找指定位置的元素
/**
* 返回指定位置的元素
*
* @param index 指定元素的位置
* @throws index越界会抛出IndexOutOfBoundsException
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
该方法直接返回
elementData
数组指定下标的元素,效率还是很高的。所以ArrayList,for
循环遍历效率也是很高的。
八、序列化方法
/**
* 将ArrayLisy实例的状态保存到一个流里面
*/
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// 按照顺序写入所有的元素
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
九、反序列化方法
/**
* 根据一个流(参数)重新生成一个ArrayList
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt();
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
十、创建子数组
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
我们看一下简短版的 SubList
:
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
private final int parentOffset;
private final int offset;
int size;
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
public E set(int index, E e) {
rangeCheck(index);
checkForComodification();
E oldValue = ArrayList.this.elementData(offset + index);
ArrayList.this.elementData[offset + index] = e;
return oldValue;
}
// 省略代码...
}
-
SubList的set()方法,是直接修改ArrayList中
elementData
数组的,使用中应该注意 -
SubList是没有实现
Serializable
接口的,是不能序列化的
十一、迭代器
1. 创建迭代器方法
public Iterator<E> iterator() {
return new Itr();
}
2. Itr属性
// 下一个要返回的元素的下标
int cursor;
// 最后一个要返回元素的下标 没有元素返回 -1
int lastRet = -1;
// 期望的 modCount
int expectedModCount = modCount;
3. Itr的hasNext() 方法
public boolean hasNext() {
return cursor != size;
}
4. Itr的next()方法
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];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
在迭代的时候,会校验
modCount
是否等于expectedModCount
,不等于就会抛出著名的ConcurrentModificationException
异常。什么时候会抛出ConcurrentModificationException
?
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
for (int i = 0; i < 10; i++) {
arrayList.add(i);
}
remove(arrayList);
System.out.println(arrayList);
}
public static void remove(ArrayList<Integer> list) {
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer number = iterator.next();
if (number % 2 == 0) {
// 抛出ConcurrentModificationException异常
list.remove(number);
}
}
}
那怎么写才能不抛出
ConcurrentModificationException
?很简单,将list.remove(number);
换成iterator.remove();
即可。请看Itr的remove()
源码…
5. Itr的remove()方法
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
// 移除之后将modCount 重新赋值给 expectedModCount
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
原因就是因为Itr的remove()方法,移除之后将modCount重新赋值给 expectedModCount。这就是源码,不管单线程还是多线程,只要违反了规则,就会抛异常。
十二、问题总结
1. ArrayList 与 Vector 的区别
-
ArrayList 是 List 的主要实现类,底层使用 Object[ ]存储,适用于频繁的查找工作,线程不安全
-
Vector 是 List 的古老实现类,底层使用 Object[ ]存储,线程安全的。
2. ArrayList 与 LinkedList 的区别
-
是否保证线程安全:
ArrayList
和LinkedList
都是不同步的,也就是不保证线程安全; -
底层数据结构:
Arraylist
底层使用的是Object
数组;LinkedList
底层使用的是 双向链表 数据结构(JDK1.6 之前为循环链表,JDK1.7 取消了循环) -
插入和删除是否受元素位置的影响:
①ArrayList
采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行add(E e)
方法的时候,ArrayList
会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话(add(int index, E element)
)时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
②LinkedList
采用链表存储,所以对于add(E e)
方法的插入,删除元素时间复杂度不受元素位置的影响,近似 O(1),如果是要在指定位置i插入和删除元素的话(add(int index, E element)
) 时间复杂度近似为o(n))因为需要先移动到指定位置再插入。 -
是否支持快速随机访问:
LinkedList
不支持高效的随机元素访问,而ArrayList
支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)
方法)。 -
内存空间占用:
ArrayList
的空间浪费主要体现在list
列表的结尾会预留一定的容量空间,而LinkedList
的空间花费则体现在它的每一个元素都需要消耗比ArrayList
更多的空间(因为要存放直接后继和直接前驱以及数据)。
3. ArrayList线程不安全,为什么还要使用
因为我们正常使用的场景中,都是用来查询,不会涉及太频繁的增删,如果涉及频繁的增删,可以使用LinkedList,如果你需要线程安全就使用Vector,这就是三者的区别了,实际开发过程中还是ArrayList使用最多的。
不存在一个集合工具是查询效率又高,增删效率也高的,还线程安全的,至于为啥大家看代码就知道了,因为数据结构的特性就是优劣共存的,想找个平衡点很难,牺牲了性能,那就安全,牺牲了安全那就快速。
4. ArrayList底层实现是数组,但是数组的大小是定长的,如果我们不断的往里面添加数据的话,不会有问题吗?
ArrayList可以通过构造方法在初始化的时候指定底层数组的大小。
通过无参构造方法的方式ArrayList()初始化,则赋值底层数Object[] elementData为一个默认空数组Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}所以数组容量为0,只有真正对数据进行添加add时,才分配默认DEFAULT_CAPACITY = 10的初始容量。
5. 数组的长度是有限制的,而ArrayList是可以存放任意数量对象,长度不受限制,那么他是怎么实现的呢?
其实实现方式比较简单,他就是通过数组扩容的方式去实现的。
就比如我们现在有一个长度为10的数组,现在我们要新增一个元素,发现已经满了,那ArrayList会怎么做呢?
第一步他会重新定义一个长度为10+10/2的数组也就是新增一个长度为15的数组。
然后把原数组的数据,原封不动的复制到新数组中,这个时候再把指向原数的地址换到新数组,ArrayList就这样完成了一次改头换面。
6. ArrayList在增删的时候是怎么做的么?他为啥慢。
他有指定index新增,也有直接新增的,在这之前他会有一步校验长度的判断ensureCapacityInternal,就是说如果长度不够,是需要扩容的。
在扩容的时候,老版本的jdk和8以后的版本是有区别的,8之后的效率更高了,采用了位运算,右移一位,其实就是除以2这个操作。
指定位置新增的时候,在校验之后的操作很简单,就是数组的copy。
画图解释一下arraycopy的代码:
比如有下面这样一个数组我需要在index 5的位置去新增一个元素A
那从代码里面我们可以看到,他复制了一个数组,是从index 5的位置开始的,然后把它放在了index 5+1的位置
给我们要新增的元素腾出了位置,然后在index的位置放入元素A就完成了新增的操作了
至于为啥说他效率低,我想我不说你也应该知道了,我这只是在一个这么小的List里面操作,要是我去一个几百几千几万大小的List新增一个元素,那就需要后面所有的元素都复制,然后如果再涉及到扩容啥的就更慢了不是嘛。
7. ArrayList(int initialCapacity)会不会初始化数组大小?
不会初始化数组大小!
而且将构造函数与initialCapacity结合使用,然后使用set()会抛出异常,尽管该数组已创建,但是大小设置不正确。
使用sureCapacity()也不起作用,因为它基于elementData数组而不是大小。
还有其他副作用,这是因为带有sureCapacity()的静态DEFAULT_CAPACITY。
进行此工作的唯一方法是在使用构造函数后,根据需要使用add()多次。
大家可能有点懵,我直接操作一下代码,大家会发现我们虽然对ArrayList设置了初始大小,但是我们打印List大小的时候还是0,我们操作下标set值的时候也会报错,数组下标越界。
这是Java Bug里面的一个经典问题了,还是很有意思的。
还不明白的话,那就看下elementData的注释,elementData作为存储ArrayList元素的数组缓冲区,ArrayList的容量是这个数组缓冲区的长度。注意,这里提到的是容量capacity,而size则是:the size of the ArrayList (the number of elements it contains).数组中包含元素的个数。
由此可见,ArrayList(int initialCapacity)并不会初始化数组大小。
8. ArrayList插入删除一定慢么?
取决于你删除的元素离数组末端有多远,ArrayList拿来作为堆栈来用还是挺合适的,push和pop操作完全不涉及数据移动操作。
9. 那他的删除怎么实现的呢?
删除其实跟新增是一样的,不过叫是叫删除,但是在代码里面我们发现,他还是在copy一个数组。
继续打个比方,我们现在要删除下面这个数组中的index5这个位置
那代码他就复制一个index5+1开始到最后的数组,然后把它放到index开始的位置
index5的位置就成功被”删除“了其实就是被覆盖了,给了你被删除的感觉。
同理他的效率也低,因为数组如果很大的话,一样需要复制和移动的位置就大了。
10. ArrayList是线程安全的么?
当然不是,线程安全版本的数组容器是Vector。
Vector的实现很简单,就是把所有的方法统统加上synchronized就完事了。
你也可以不使用Vector,用Collections.synchronizedList把一个普通ArrayList包装成一个线程安全版本的数组容器也可以,原理同Vector是一样的,就是给所有的方法套上一层synchronized。
11. ArrayList用来做队列合适么?
队列一般是FIFO(先入先出)的,如果用ArrayList做队列,就需要在数组尾部追加数据,数组头部删除数组,反过来也可以。
但是无论如何总会有一个操作会涉及到数组的数据搬迁,这个是比较耗费性能的。
结论:ArrayList不适合做队列。
12. 那数组适合用来做队列么?
数组是非常合适的。
比如ArrayBlockingQueue内部实现就是一个环形队列,它是一个定长队列,内部是用一个定长数组来实现的。
另外著名的Disruptor开源Library也是用环形数组来实现的超高性能队列,具体原理不做解释,比较复杂。
简单点说就是使用两个偏移量来标记数组的读位置和写位置,如果超过长度就折回到数组开头,前提是它们是定长数组。
13. ArrayList的遍历和LinkedList遍历性能比较如何?
论遍历ArrayList要比LinkedList快得多,ArrayList遍历最大的优势在于内存的连续性,CPU的内部缓存结构会缓存连续的内存片段,可以大幅降低读取内存的性能开销。
14. 为什么空实例默认数组有的时候是EMPTY_ELEMENTDATA,而又有的时候是DEFAULTCAPACITY_EMPTY_ELEMENTDATA
先看构造方法、添加方法、扩容方法源码。
new ArrayList()
会将 elementData
赋值为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
,new ArrayList(0)
会将 elementData
赋值为 EMPTY_ELEMENTDATA
,EMPTY_ELEMENTDATA
添加元素会扩容到容量为 1
,而 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
扩容之后容量为 10
。
15. 为什么elementData要被transient修饰
ArrayList重写了序列化、反序列化方法,避免序列化、反序列化全部数组,浪费时间和空间
elementData之所以用 transient
修饰,是因为JDK不想将整个 elementData
都序列化或者反序列化,而只是将 size
和实际存储的元素序列化或反序列化,从而节省空间和时间。
16. 为什么elementData没有被private修饰?
可以简化内部类的访问