属性:
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L; // 数组默认长度 private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ // 对于空实例对象来说,都是共享的 private static final Object[] EMPTY_ELEMENTDATA = {}; /** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */ // 空实例对象默认共享的实例的数组。 // 用来区分每个空实例指向的数组位置在第一次添加元素进来的时候 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. Any * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA * will be expanded to DEFAULT_CAPACITY when the first element is added. */ // 真正存储数据的数组。前面是transient关键字表示的不可以进行序列化 transient Object[] elementData; // non-private to simplify nested class access // 数组中元素的个数 private int size;
直接构造方法:
第一种就是直接指定数组的大小:
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); } }
第二种就是默认不指定:
public ArrayList() { // 在不指定数组容量大小的时候,使用的是这个数组 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
第三种就是转换方法:
public ArrayList(Collection<? extends E> c) { // 将每个元素转换成 Object[] a = c.toArray(); if ((size = a.length) != 0) { // 如果直接是ArrayList,那么就可以直接进行转换了 if (c.getClass() == ArrayList.class) { elementData = a; } else { // 如果不是,可能是set、linkedList等,转换成Object类型的 elementData = Arrays.copyOf(a, size, Object[].class); } } else { // replace with empty array. // 如果为0,就可以使用这个 elementData = EMPTY_ELEMENTDATA; } }
那么接着看下这里的toArray方法:
public Object[] toArray() { return Arrays.copyOf(elementData, size); }
除了第三种构造方法不做说明,介绍下第一种构造和第二种构造的区别,如果指定了容量(>0),那么首先会创建好一个数组;而没有指定的,就会直接指向一个空数组。但是如果容量为0和使用无参构造,这个时候也是有点区别的。最大的区别就是在于两个集合实例使用的数组不同。
直接看重要方法:
public boolean add(E e) { // 确保容量是否足够 ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
第一步做的事情就是先去检查容量是否足够放进去一个新的元素;
两种情况:如果足够,那么放入进去即可;如果不够,那么需要先来进行扩容;看下具体代码:
private void ensureCapacityInternal(int minCapacity) { // 又继续调了两层。首先看calculateCapacity方法(计算容量) ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }
calculateCapacity方法源码如下所示:
private static int calculateCapacity(Object[] elementData, int minCapacity) { // 从前面的介绍中,可以看到这个是无参构造方法空实例的数组 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 数组默认大小和第size+1个元素是否能够放进去 // 这里就是说,加入的元素的个数和数组默认大小10比较,取出来最大值 return Math.max(DEFAULT_CAPACITY, minCapacity); } // 如果elementData不是指向这个地址,那么就只有一种情况,走有参构造方法 // 初始化容量是0或者是大于0 return minCapacity; }
再回到刚刚调用这个方法的地方,继续执行,走ensureExplicitCapacity方法:
private void ensureExplicitCapacity(int minCapacity) { // 隐藏在父类中的属性,表示的是数组中的元素修改的次数 modCount++; // 可能会移除的代码块 // 如果添加进来的元素的个数已经可以将其放满了,那么就需要扩容 // 如果小于或者是等于,那么就先不扩容。 // 至于等于的情况,就是说数组长度可能是10,当前已经放了九个元素了,然后第十个元素需要放置进来 // 的时候,发现是等于10的,这里会等于0.因为还会剩下一个位置,所以可以继续放进去。 if (minCapacity - elementData.length > 0) grow(minCapacity); }
可以看下grow代码:
private void grow(int minCapacity) { // 可能会溢出的代码 // 首先计算出当前的数组的容量 int oldCapacity = elementData.length; // 从这里可以看到扩容的倍数是1.5 // 但是第一次扩的时候,如果elementData.length为0的话,那么这里相当于是没有进行扩容的 int newCapacity = oldCapacity + (oldCapacity >> 1); // 这里会做一步赋值。也就是说扩容之后,新的比原来的还小,那么将原来的。对应的是就是上面的 // 如果初始条件下为0的时候 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); }