java7集合源码解析_Java集合：ArrayList （JDK1.8 源码解读）

ArrayList

ArrayList几乎是每个java开发者最常用也是最熟悉的集合，看到ArrayList这个名字就知道，它必然是以数组方式实现的集合

关注点

说一下ArrayList的几个特点，也是面试喜欢问的几个点：

1.是否允许为空：是

2.是否允许重复数据：是

3.是否有序：是

4.是否线程安全：否

主要声明

看一下ArrayList的声明：

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

ArrayList继承自AbstractList，并且实现了List接口(还实现了RandomAccess、Cloneable、Serializable)，List接口又继承自顶层集合接口Cellection，实现了List接口就代表它是一个有序的集合

再看一下ArrayList声明的主要变量：

//默认容量

private static final int DEFAULT_CAPACITY = 10;//一个空的数组

private static final Object[] EMPTY_ELEMENTDATA ={};//默认容量的空数组，搞这么多空数组干嘛？|_・)

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};//ArrayList的核心，elemenData就是底层的数组

transientObject[] elementData;//数组所包含的元素数量

private int size;

这里做一下几个主要变量的说明：

1.DEFAULT_CAPACITY 并不是ArrayList的初始大小，只是默认大小

2.EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA 就是两个空的对象数组，后面会在构造方法里面用到

3.ArrayList是基于数组的一个实现，elementData就是底层的数组

4.size数组所包含的元素的数量，ArrayList的size()方法返回的就是这个size的值

看完这些，我们来写个例子实际操作一下：

public static voidmain(String[] args)

{

List list = new ArrayList<>();//List list = new ArrayList<>(10);

list.add("111");

list.add("222");

}

构造方法

1.无参构造器

publicArrayList() {this.elementData =DEFAULTCAPACITY_EMPTY_ELEMENTDATA;// this(10)jdk1.6写法

}

直接把声明的空数组丢给elementData，也就是说ArrayList在jdk1.8中初始化的时候大小是0，并不是10，这和jdk1.6有区别

2.带初始化容量大小的构造器，上面例子中注释掉的代码的用法

public ArrayList(intinitialCapacity) {if (initialCapacity > 0) {this.elementData = newObject[];

}else if (initialCapacity == 0) {this.elementData =EMPTY_ELEMENTDATA;

}else{throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);

}

}

传递一个int类型的参数initialCapacity作为ArrayList的初始化大小，如果initialCapacity大于0，则声明一个initialCapacity大小的对象数组给elementData赋值，如果initialCapacity为0就把声明的空对象数组给elementData，如果小于0你懂的

3. 还有一种构造器例子中未展示的 public ArrayList(Collection extends E> c) 传一个集合进去，也比较简单就是把集合转成数组赋值给elementData

添加元素

照着例子继续往下看，添加元素的时候，ArrayList会做什么，看看add的源码：

1 public booleanadd(E e) {2 ensureCapacityInternal(size + 1);3 elementData[size++] =e;4 return true;5 }6

7 private void ensureCapacityInternal(intminCapacity) {8 if (elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {9 minCapacity =Math.max(DEFAULT_CAPACITY, minCapacity);10 }11 ensureExplicitCapacity(minCapacity);12 }13

14 private void ensureExplicitCapacity(intminCapacity) {15 modCount++;16 if (minCapacity - elementData.length > 0)17 grow(minCapacity);18 }

第二行代码是扩容用的我们先不管，直接看第三行，第三行告诉我们再调用add方法往集合里面添加元素的时候只是给对象数组加了一个元素而已，画图来说明一下

扩容

new ArrayList()的时候构造方法只给了一个DEFAULTCAPACITY_EMPTY_ELEMENTDATA声明的空对象数组，为什么例子的add方法的第三行还能执行往elementData里面添加元素，那么扩容就出现了

看第七行的ensureCapacityInternal(int minCapacity)方法(注：size表示数组内元素个数，那么我要往数组添加一个元素，minCapacity就是数组执行添加时最小需要的容量)，执行add("111")，ArrayList的size初始值为0，那么minCapacity的值就为1，看第8行此时elementData是不是就是那个空的对象数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA,

继续往下，把minCapacity赋值为minCapacity和默认容量两者的最大值，minCapacity的值就成了10，然后minCapacity最小容量和数组长度去比较，数组的长度已经不能满足添加元素后的最小容量，数组就会去执行扩容的grow(minCapacity)方法进行数组扩容，所以ArrayList触发扩容的条件就是数组长度不够了或者说数组已经装满了，看一下grow方法具体：

1 private void grow(intminCapacity) {2 int oldCapacity =elementData.length;3 int newCapacity = oldCapacity + (oldCapacity >> 1);4 if (newCapacity - minCapacity < 0)5 newCapacity =minCapacity;6 if (newCapacity - MAX_ARRAY_SIZE > 0)7 newCapacity =hugeCapacity(minCapacity);8 elementData =Arrays.copyOf(elementData, newCapacity);9 }

简单的说一下，第三行：新的数组长度=原数组长度 + 原数组长度的一半，这里使用的位运算>>1 ，oldCapacity是偶数就是一半，基数就是(oldCapacity-1)/2，因为长度必须得是整数，jdk1.6中使用的是 newCapacity = (oldCapacity * 3)/2 + 1，所以当别人问你ArrayList每次扩容多少时，你可以说扩容了二分之一的大小

问题：至于为什么要扩容二分之一？

可以看第八行代码，当确定了新数组长度之后，会把旧的elementData复制到一个新的长度为newCapacity的数组中去然后赋值给原来的elementData数组，如图

1.如果扩容的太少，则必须频繁的进行扩容操作，频繁的复制数组这必然会降低效率

2.如果扩容的太多，数组内就会有很多空闲的位置，就会造成空间上的浪费

所以JDK的开发人员必定是经过考量和权衡才会决定扩容的大小

插入元素

ArrayList在进行插入操作的时候也是使用的add方法，举个例子：

1 List list = new ArrayList<>();2 list.add("11");3 list.add("33");4 list.add("44");5 list.add("55");6 list.add(2,"22");//插入元素

第六行便是往ArrayList里面插入元素，看一下list.add(2,"22")执行的操作：

1 public void add(intindex, E element) {2 rangeCheckForAdd(index);3

4 ensureCapacityInternal(size + 1);

5 System.arraycopy(elementData, index, elementData, index + 1,size -index);7 elementData[index] =element;8 size++;9 }

先检查插入的下标是否小于0或者大于数组内元素的个数，如果不在这个范围内抛出数组下标越界IndexOutOfBoundsException

判断下标合法性之后和添加元素一样判断是否需要扩容，然后按照下标指定的位置，把elementData数组内从指定位置开始的所有元素利用System.arraycopy方法做一个整体复制，向后移动一个位置，并且为指定下标位置插入对应的元素，画图表示一下这个过程：

删除元素

ArrayList提供了两种删除元素的方法：

1.通过指定下标删除

2.通过指定元素删除

先看第一种：

1 public E remove(intindex) {2 rangeCheck(index);3

4 modCount++;5 E oldValue =elementData(index);6

7 int numMoved = size - index - 1;8 if (numMoved > 0)9 System.arraycopy(elementData, index+1, elementData, index,10 numMoved);11 elementData[--size] = null; //clear to let GC do its work

12

13 returnoldValue;14}

同样的先检查指定下标的合法性，是否在可删除范围内，记录要删除的元素，return的时候返回删除的元素，然后获取需要复制的数组长度，除非你指定删除的位置就是数组的最后一个元素，否则就是同样的套路，复制指定下标+1位置开始的元素，向前移动一个位置，并且给数组元素最后一个元素赋值null，让GC来回收它，来个图表示一下：

再来看第二种按照元素删除：

1 public booleanremove(Object o) {2 if (o == null) {3 for (int index = 0; index < size; index++)4 if (elementData[index] == null) {5 fastRemove(index);6 return true;7 }8 } else{9 for (int index = 0; index < size; index++)10 if(o.equals(elementData[index])) {11 fastRemove(index);12 return true;13 }14 }15 return false;16 }

遍历数组寻找匹配的元素，只不过元素为null的时候使用的==判断其他类型都使用equals方法判断，如果匹配了就执行fastRemove，fastRemove干了啥呢？

1 private void fastRemove(intindex) {2 modCount++;3 int numMoved = size - index - 1;4 if (numMoved > 0)5 System.arraycopy(elementData, index+1, elementData, index,6 numMoved);7 elementData[--size] = null; //clear to let GC do its work

8 }

这不就是按照下标删除的操作吗？所以这两种删除方式的差别就是第一种返回被删除的元素，第二种删除匹配元素返回true，没有匹配元素返回false

到这里ArrayList的基本操作就讲完了，总结一下：

ArrayList的优点：

1.ArrayList层是数组实现的，支持随机访问，并且实现了RandomAccess接口，所以查找数据非常快

2.顺序添加非常快，只是往数组尾部添加了一个元素

3.从尾部删除也非常方便，只是把最后一个元素变成了null，等待GC回收

ArrayList的缺点：

1.如果从中间插入元素或者删除元素会涉及到数组元素的复制，如果复制的元素太多非常耗费性能

2.ArrayList的底层数组是个动态数组，大小会随着元素的增加而进行扩容，扩容涉及到数组元素的复制，会消耗性能和空间，所以如果在使用ArrayList的时候能确定或者大概知道数据量大小，在new ArrayList的时候请一个合理的初始化大小，避免频繁扩容

总的来说ArrayList适合顺序添加，随机访问的使用场景

ArrayList和Vector的区别

ArrayList里面的方法都不是线程同步的，所以ArrayList的线程是不安全的，在多线程情况下会有线程安全问题，可以使用Collections.synchronizedList方法把你的ArrayList变成一个线程安全的List

List synchronizedList = Collections.synchronizedList(list);

还有一种方法就是使用Vector，Vector和ArrayList的实现方式几乎一样，只不过Vector的大部分public方法都是加了synchronized，ArrayList和Vector主要有两个区别：

1.Vector线程安全

2.Vector可以指定增长因子，扩容的时候原数组会增加增长因子个大小，如果增长因子缺省那么就会增加一倍的大小

int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);

来源：oschina

链接：https://my.oschina.net/u/4352263/blog/4171187