ArrayList源码阅读
起源
这里说的起源不是ArrayList,而是插个题外话,为什么要开始源码阅读?本人研二,上周接到阿里的内推电话测评面试,20分钟左右,最后问了Java基础的ArrayList。心想,这个有啥好问的,但由于当时内心还是比较紧张的,所以说的不清不楚,说到底层说了初始为10容量,每次扩容50%,但问到每次怎么实现扩容的,当时就想着是基于数组实现的,具体怎么实现的还真一时没说上来。虽说面试整体还可以,但是最后这题给我留下不小的阴影。感觉基础不扎实。确实,从开始学Java开始,都是看书和实践一些demo,而没有从源码着手。如果看懂了源码,不但理解原理,底层的实现也会很清楚。记得很早的时候一位师兄告诉我说学Java比较方便的一点是可以看源码。
千里之行,始于足下,我们慢慢来,踏踏实实!
ArrayList源码阅读
定义
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
继承了AbstractList抽象类,实现了List,RandomAccess,Cloneable,Serializable接口。后面三个为标记接口,从接口名可以看出大致意思(随机访问、可克隆、可序列化)。
成员变量
1. private static final long serialVersionUID =8683452581122892189L;
serialVersionUID适用于Java的序列化机制。简单来说,Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。这里了解一下就好,和ArrayList本身无关。
2. private static final int DEFAULT_CAPACITY = 10;
默认初始容量,10
3. private static final Object[] EMPTY_ELEMENTDATA = {};
4. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
上面两个放一起说,共享空常量数组,用于空的实例对象,第二个与第一个的区别文档上面是这么说的:We distinguish this from EMPTY_ELEMENTDATA to know how much toinflate when first element is added., 翻译一下就是与EMPTY_ELEMENTDATA数组的区别在于当第一个元素被加入进来的时候它知道如何扩张;看下面add(E e)源码中的第一行代码中的所在的函数就是这句话的实现。
5. transient Object[] elementData;
用来存储ArrayList中的元素,很明显,底层是基于数组实现的。
6. private int size;
记录ArrayList中存储元素的个数。
构造方法
构造方法有三个:
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
构造一个初始容量为10的空列表。
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(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
构造一个包含指定collection 的元素的列表,这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
成员方法
add(E e)
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
modCount为AbstractList继承来的字段,表示修改了多少次。
ensureCapacityInternal(size + 1),私有方法,增加元素后是否超过容量需要扩容。
add方法操作就是对数组上的操作。
add(int index, E element)
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++; }
私有方法rangeCheckForAdd(index),检查index的合法性在0~size之间。
其他同add(E e)方法。
addAll(Collection<? extends E> c)
按照指定collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到此列表的尾部
public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; }
先将collection转换为数组,然后检查是否需要扩容,使用本地方法进行数组复制。
addAll(int index, Collection<? extends E> c)
从指定的位置开始,将指定collection 中的所有元素插入到此列表中。
public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; }
同样检查index合法性,判断扩容,先将elementData数组位置空出来,然后将插入的值复制进去。
clear()
public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; }
不用解释,全置为null。
clone()
返回此 ArrayList 实例的浅表副本。
public Object clone() { try { ArrayList<?> v = (ArrayList<?>) super.clone(); v.elementData = Arrays.copyOf(elementData, size); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(e); } }
很明显,只是复制了一份引用到新的ArrayList中。
contains(Object o)
public boolean contains(Object o) { return indexOf(o) >= 0; }
返回该对象在该list中的下标是否在合法范围内,从而得出是否包含该元素。
ensureCapacity(int minCapacity)
如有必要,增加此ArrayList 实例的容量,以确保它至少能够容纳最小容量参数所指定的元素数。
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); } }
如果elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA,则最小扩展10,否则为0。然后判断minCapacity是否需要扩容情况。
get(int index)
返回此列表中指定位置上的元素。
public E get(int index) { rangeCheck(index); return elementData(index); }
先检查index合法性,然后返回底层数组的元素。
indexOf(Object o)
返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1。
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; }
使用Object的equals()方法进行判断,是否为同一元素,返回下标,不存在返回-1。
isEmpty()
判断列表是否为空
public boolean isEmpty() { return size == 0; }
直接返回size==0
lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1。
public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; }
同上相反,for循环初始条件可以看出,从后往前。
remove(int index)
移除此列表中指定位置上的元素。
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; }
检查index合法性,保存需要remove的值在oldValue中,移动底层数组,减少容量,返回oldValue。
remove(Object 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; }
和indexOf(Objecto)类似,先找到元素,然后执行fastRemove()(元素移动),注意返回值和remove(int index)不同。
set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; }
检查合法性,保存原值oldValue,将新值插入,返回oldValue。
size()
返回列表长度
public int size() { return size; }
toArray()
按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组。
public Object[] toArray() { return Arrays.copyOf(elementData, size); }
返回elementData一份浅拷贝。
toArray(T[] a)
按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; }
这里需要判断数组a的长度,返回相同的拷贝。
trimToSize()
将此 ArrayList 实例的容量调整为列表的当前大小。
public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } }
由于列表的增加删除,导致列表有多余空间需要释放(实际的size小于elementData数组的实际大小)。如果为空,则变为EMPTY_ELEMENTDATA,否则复制数组。
private void grow(int minCapacity)
ArrayList的一个扩容操作,私有方法,底层自动扩容,保证列表中容得下minCapacity大小的元素。
很明显,每次扩容newCapacity= oldCapacity + (oldCapacity >> 1),如果还不够就直接扩容为newCapacity,如果这个newCapacity比MAX_ARRAY_SIZE还大,则扩容到Integer.MAX_VALUE,一般用不到吧。
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); }
小结
看完源码,其实ArrayList比较简单,看的也很快,没有难懂的地方,但是看完后思路会更加清晰,比看所有书本上说的要更容易理解透彻。
后续会继续阅读一些Java源码,然后扩展到一些框架的源码阅读,加油!