目录
list.sort(new Comparator() {});
前言:作为一个常用的List接口实现类,日常开发过程中使用率非常高,因此有必要对其原理进行分析。
注:本文jdk源码版本为jdk1.8.0_172
1.ArrayList介绍
ArrayList底层数据结构是数组(数组是一组连续的内存空间),默认容量为10,它具有动态扩容的能力,线程不安全,元素可以为null。
笔者在一次使用ArrayList的时候引起了一次线上OOM,分析传送门:记一次ArrayList产生的线上OOM问题
1 java.lang.Object
2 ↳ java.util.AbstractCollection<E>
3 ↳ java.util.AbstractList<E>
4 ↳ java.util.ArrayList<E>
5
6 public class ArrayList<E> extends AbstractList<E>
7 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
2.主要源码分析
new ArrayList<String>();
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
add(e):
1 /**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
public boolean add(E e) {
2 // 确认容量
3 ensureCapacityInternal(size + 1); // Increments modCount!!
4 // 直接将元素添加在数组中
5 elementData[size++] = e;
6 return true;
7 }
8
9 private void ensureCapacityInternal(int minCapacity) {
10 // 进一步确认ArrayList的容量,看是否需要进行扩容
11 ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
12 }
13
14 private static int calculateCapacity(Object[] elementData, int minCapacity) {
15 // 如果elementData为空,则返回默认容量和minCapacity中的最大值
16 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
17 return Math.max(DEFAULT_CAPACITY, minCapacity);
18 }
19 // 否则直接返回minCapacity
20 return minCapacity;
21 }
22
23 private void ensureExplicitCapacity(int minCapacity) {
24 // 修改次数自增
25 modCount++;
26
27 // overflow-conscious code
28 // 判断是否需要扩容
29 if (minCapacity - elementData.length > 0)
30 grow(minCapacity);
31 }
32
33 private void grow(int minCapacity) {
34 // overflow-conscious code
35 // 原容量
36 int oldCapacity = elementData.length;
37 // 扩容,相当于扩大为原来的1.5倍
38 int newCapacity = oldCapacity + (oldCapacity >> 1);
39 // 确认最终容量
40 if (newCapacity - minCapacity < 0)
41 newCapacity = minCapacity;
42 if (newCapacity - MAX_ARRAY_SIZE > 0)
43 newCapacity = hugeCapacity(minCapacity);
44 // minCapacity is usually close to size, so this is a win:
45 // 将旧数据拷贝到新数组中
46 elementData = Arrays.copyOf(elementData, newCapacity);
47 }
48
49
分析:
其实add方法整体逻辑还是比较简单。主要注意扩容条件:只要插入数据size比原来大就会进行扩容。因此如果在循环中使用ArrayList时需要特别小心,避免频繁扩容造成OOM异常。
add(int index, E element):
1 public void add(int index, E element) {
2 // 越界检查
3 rangeCheckForAdd(index);
4
5 // 确认容量
6 ensureCapacityInternal(size + 1); // Increments modCount!!
7 // 将index及其之后的元素往后移动一位,将index位置空出来
8 System.arraycopy(elementData, index, elementData, index + 1,
9 size - index);
10 // 在index插入元素
11 elementData[index] = element;
12 // 元素个数自增
13 size++;
14 }
分析:
整体逻辑简单:越界检查->确认容量->元素后移->插入元素。
get函数:
1 public E get(int index) {
2 // 越界检查
3 rangeCheck(index);
4 // 获取对应位置上的数据
5 return elementData(index);
6 }
7
8 private void rangeCheck(int index) {
9 if (index >= size)
10 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
11 }
12
13 E elementData(int index) {
14 return (E) elementData[index];
15 }
分析:
get操作简单,理解容易。
remove(index):
1 public E remove(int index) {
2 // 越界检查
3 rangeCheck(index);
4
5 // 修改次数自增
6 modCount++;
7 // 获取对应index上的元素
8 E oldValue = elementData(index);
9
10 // 判断index是否在最后一个位置
11 int numMoved = size - index - 1;
12 // 如果不是,则需要将index之后的元素往前移动一位
13 if (numMoved > 0)
14 System.arraycopy(elementData, index+1, elementData, index,
15 numMoved);
16 // 将最后一个元素删除,帮助GC
17 elementData[--size] = null; // clear to let GC do its work
18
19 return oldValue;
20 }
分析:
remove逻辑还是比较简单,但是这里需要注意一点是ArrayList在remove的时候,并没有进行缩容。
remove(o):
1 public boolean remove(Object o) {
2 // 如果被移除元素为null
3 if (o == null) {
4 // 循环遍历
5 for (int index = 0; index < size; index++)
6 // 注意这里判断null是用的“==”
7 if (elementData[index] == null) {
8 // 快速remove元素
9 fastRemove(index);
10 return true;
11 }
12 } else {
13 for (int index = 0; index < size; index++)
14 // 这里判断相等是用的equals方法,注意和上面对比
15 if (o.equals(elementData[index])) {
16 fastRemove(index);
17 return true;
18 }
19 }
20 return false;
21 }
22
23 private void fastRemove(int index) {
24 // 注意这里并未做越界检查,毕竟叫fastRemove
25 // 修改次数自增
26 modCount++;
27 // 判断是否是最后一个元素,这里的操作和remove(index)是一样的
28 int numMoved = size - index - 1;
29 if (numMoved > 0)
30 System.arraycopy(elementData, index+1, elementData, index,
31 numMoved);
32 elementData[--size] = null; // clear to let GC do its work
33 }
分析:
remove元素的时候分为null和非null,并且是快速remove,并未做越界检查。
retainAll:求交集
1 public boolean retainAll(Collection<?> c) {
2 // 判空
3 Objects.requireNonNull(c);
4 // 批量remove complement为true表示保存包含在c集合的元素,这样就求出交集了
5 return batchRemove(c, true);
6 }
7
8 private boolean batchRemove(Collection<?> c, boolean complement) {
9 final Object[] elementData = this.elementData;
10 // 读写指针 读指针遍历,写指针只有在条件符合时才自增,这样不需要额外的空间
11 int r = 0, w = 0;
12 boolean modified = false;
13 try {
14 // 遍历
15 for (; r < size; r++)
16 // 如果c集合中包含遍历元素,则把元素放入写指针位置(以complement为准)
17 if (c.contains(elementData[r]) == complement)
18 elementData[w++] = elementData[r];
19 } finally {
20 // Preserve behavioral compatibility with AbstractCollection,
21 // even if c.contains() throws.
22 // 正常情况下,r与size是相等的,这里是对异常的判断
23 if (r != size) {
24 // 将未读的元素拷贝到写指针后面
25 System.arraycopy(elementData, r,
26 elementData, w,
27 size - r);
28 w += size - r;
29 }
30 // 将写指针后的元素全部置空
31 if (w != size) {
32 // clear to let GC do its work
33 for (int i = w; i < size; i++)
34 elementData[i] = null;
35 modCount += size - w;
36 size = w;
37 modified = true;
38 }
39 }
40 return modified;
41 }
分析:
将集合与另一个集合求交集,整体逻辑比较简单的。通过读写指针进行操作,不用额外空间。注意complement为true,则将包含在c中的元素写入相应位置。这样就求出了交集,这里还要注意finally中的操作,异常与置空操作。
removeAll:求差集
但是这里只保留当前集合不在C中的元素,不保留C中不在当前集合中的元素。
1 public boolean removeAll(Collection<?> c) {
2 // 判空
3 Objects.requireNonNull(c);
4 // 批量remove,注意这里complement为false,表示保存不在c中的元素,这样就求出差集了
5 return batchRemove(c, false);
6 }
分析:
逻辑和retainAll刚好相反,complement为false,保存不包含在C中的元素,这样就求出差集了,注意这里是单向差集。
list.sort(new Comparator<String>() {});
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
3.总结
以上分析了ArrayList的主要源码,下面对其进行总结:
#1.ArrayList的底层数据结构为数组(数组是一组连续的内存空间),默认容量为10,线程不安全,可以存储null值。
#2.ArrayList扩容条件,只要增加容量大于现有容量就会进行扩容,扩容量为原来的1.5倍,但是ArrayList不会进行缩容。
#3.ArrayList中有求交集(retainAll)和求差集(removeAll),注意这里的差集是单向交集。
ArrayList底层实现结构是数组
ArrayList无参构造默认初始为空数组,之后有添加操作时,默认初始10大小数组
ArrayList 常见rangeCheck,会抛出IndexOutOfBoundsException
ArrayList 父类AbstractList维护一个变量modCount,记录了集合修改次数(增删改)
后面使用迭代器遍历会校验这个变量,从而抛出ConcurrentModificationException
ArrayList 判断元素是否相等用的时元素的equals方法,因此重写equals方法需要注意,有可能会造成内存泄露
ArrayList 调用sort方法,使用的时Arrays的静态sort方法,如果元素没有实现Comparable接口,也没有传入Comparator比较器,那么会抛出ClassCastException
ArrayList 是一个非线程安全的集合类
ArrayList 为参考数组排序的swap交换数组元素方法可以参考