本章节主要讲述ArrayList集合知识,主要包括ArrayList结构类型,集合特点,源码解析等。
欢迎持续关注阅读,一起学习,共同交流(477819525君羊)。
1 ArrayList类层次结构:
2 ArrayList特性:
a) ArrayList是基于数组实现的,是一个动态数组,可以动态的增加和减少元素,灵活的设置数组大小。
b) ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的CopyOnWriteArrayList类。
注:concurrent并发工具包相关类,会在之后文章中做具体讲解,本文不做赘述,如需了解请查阅相关文章。
c) 每个ArrayList实例都有一个容量(初始容量默认为10)。随着向ArrayList中不断添加元素,其容量也自动增长。
注:此实现不是同步的。如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。
d) 对于ArrayList而言,它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。
e) 注意扩充容量的方法ensureCapacityInternal。ArrayList在每次增加元素(可能是1个,也可能是一组)时,都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时,就设置新的容量为旧的容量的右移一位+旧容量,如果设置后的新容量还不够,则直接新容量设置为传入的参数(也就是所需的容量),而后用Arrays.copyof()方法将元素拷贝到新的数组。从中可以看出,当容量不够时,每次增加元素,都要将原来的元素拷贝到一个新的数组中,非常之耗时,也因此建议在事先能确定元素数量的情况下,才使用ArrayList,否则建议使用LinkedList。
f) ArrayList是稳定,无序的。稳定性(Order)指集合每次遍历的元素次序是一定的。有序性(Sort)是指遍历的结果按某种比较规则依次排序的。
3 ArrayList源码分析(不同jdk版本源码结构有所不同,本文参考jdk7):
a) ArrayList类
ArrayList类实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了RandomAccess接口(接口没有定义任何内容),支持快速随机访问,实际上就是通过下标序号进行快速访问,实现了Cloneable接口,能被克隆。
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{123123
b) 私有属性:
ArrayList只定义两个私有属性:elementData存储ArrayList内的元素,size表示它包含的元素的数量。
private transient Object[] elementData; /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size;1234567812345678
有个关键字需要解释:transient。
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。(比如,保存用户对象信息,用户包括name,age,sex属性信息,如果不想保存age到数据库,可以对age加上关键字transient, 被标记为transient的属性在对象被序列化的时候不会被保存)。
c) 构造方法:
ArrayList提供了三种方式的构造器,第一个构造方法使用initialCapacity初始化elementData数组的大小,第二个构造方法,可以构造一个默认初始容量为10的空列表,第三个构造方法则将提供的集合转成数组返回给elementData(返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[])。
public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { super(); this.elementData = EMPTY_ELEMENTDATA; } /** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection‘s * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */ public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); }1234567891011121314151617181920212223242526272829303112345678910111213141516171819202122232425262728293031
d) 重点看一下add(E e)方法:
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }1234512345
可以看到,add方法,先调用一个确保(调整)内部容量的方法,之后将元素赋给elementData数组,然后size自增,将元素赋给elementData[size]不是会出现下标越界吗,关键就在ensureCapacityInternal(size + 1)中。
private void ensureCapacityInternal(int minCapacity) { if (elementData == EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }123456789101112131415123456789101112131415
在ensureCapacityInternal方法中判断elementData数组是否为空数组,如果为空,根据Max.max()得到初始容量和当前size两者之间的最大值。
在ensureExplicitCapacity方法对modCount自增,modCount是记录list结构被改变的次数(每次调用ensureExplicitCapacity方法,modCount的值都将增加,但未必数组结构会改变,所以感觉对modCount的解释不是很到位)。如果添加新元素后,当前size+1大于数组容量,就执行grow方法。
在grow方法中,具体完成扩容实现和数组的copy,可以看出容量扩充的方式是数组容量+数组容量右移一位,基本上等于扩容为原来的1.5倍。数组容量的极限是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); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }1234567891011121314151617181912345678910111213141516171819
数组拷贝通过Arrays.copyof()和System.arraycopy()方法完成。
首先来看Arrays.copyof()方法。它有很多个重载的方法,但实现思路都是一样的,我们来看泛型版本的源码:
public static <T> T[] copyOf(T[] original, int newLength) { return (T[]) copyOf(original, newLength, original.getClass()); }123123
很明显调用了另一个copyof方法,该方法有三个参数,最后一个参数指明要转换的数据的类型,实现如下:
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> 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; }1234567812345678
这里可以很明显地看出,该方法实际上是在其内部又创建了一个长度为newlength的数组,调用System.arraycopy()方法,将原来数组中的元素复制到了新的数组中。
下面来看System.arraycopy()方法。
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);123123
该方法被标记了native,调用了系统的C/C++代码,在JDK中是看不到的,但在openJDK中可以看到其源码。该函数实际上最终调用了C语言的memmove()函数,因此它可以保证同一个数组内元素的正确复制和移动,比一般的复制方法的实现效率要高很多,很适合用来批量处理数组。Java强烈推荐在复制大量数组元素时用该方法,以取得更高的效率。