ArrayList的继承关系
定义一个ArrayList的方法
ArrayList的三个构造函数:
1.无参
//默认创建一个ArrayList集合 ArrayList<String> arrayList1 = new ArrayList<>();
2.参数为整数
//创建一个初始长度为20的ArrayList集合 ArrayList<String> arrayList2 = new ArrayList<>(20);
3.参数为集合
//将其它类型的集合转化为ArrayList ArrayList<String> arrayList3 = new ArrayList<>(new HashSet());
我们读ArrayList的构造函数源码之前,先看看ArrayList的属性情况:
1 /** 2 * Default initial capacity. 3 */ 4 private static final int DEFAULT_CAPACITY = 10; 5 6 /** 7 * Shared empty array instance used for empty instances. 8 */ 9 private static final Object[] EMPTY_ELEMENTDATA = {}; 10 11 /** 12 * Shared empty array instance used for default sized empty instances. We 13 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when 14 * first element is added. 15 */ 16 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 17 18 /** 19 * The array buffer into which the elements of the ArrayList are stored. 20 * The capacity of the ArrayList is the length of this array buffer. Any 21 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 22 * will be expanded to DEFAULT_CAPACITY when the first element is added. 23 */ 24 transient Object[] elementData; // non-private to simplify nested class access 25 26 /** 27 * The size of the ArrayList (the number of elements it contains). 28 * 29 * @serial 30 */ 31 private int size;
可以看到,ArrayList是非线程安全的容器,底层实现是Object[],数据会添加到ArrayList的elementData数组中,而且默认容量DEFAULT_CAPACITY=10
。但其实在jdk7之后,ArrayList的默认容量就是0了,而且DEFAULT_CAPACITY在扩容的过程中才会用到。
我们再看看ArrayList的三种构造函数。
ArrayList有参构造函数-参数类型为整型
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); } }
可以看到,如果传入正整数,则elementData数组容量初始化为initiaCapacity;如果传入0,则elementData数组赋值为一个空数组。可能有读者发现
ArrayList类中有两个属性定义为空数组。
为什么ArrayList会定义两个空数组?
注释中给出了官方的解释
/** * 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 = {};
简而言之,EMPTY_ELEMENTDATA与DEFAULTCAPACITY_EMPTY_ELEMENTDATA在功能上有不同的意义,前者是单纯用于赋值为空数组,
后者是给elementData数组初始化的。
ArrayList有参构造函数-参数类型为集合类
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的集合类,都会调用toArray()将集合类中的数组赋给elementData。而且toArray()返回的数组类型不是Object[]类型时
...etc,toArray()返回的数组类型为什么会不是Object[]类型?举个栗子:
public class Test<E> extends ArrayList{ @Override public Integer[] toArray() { return new Integer[] {0,23}; } public static void main(String[] args) { Object[] elementData = new Test<Integer>().toArray(); System.out.println(elementData.getClass()); System.out.println(Object[].class); System.out.println(elementData.getClass()==Object[].class); } }
运行结果为:
好,我们接着说当toArray()返回的数组类型不是Object[]类型时,会调用Arrays.copyOf()将原数组拷贝到新数组去,而且类型还可以定义为Object类:
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { @SuppressWarnings("unchecked") 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; }
ArrayList无参构造函数
/** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
在这里,我们可以看到,jdk1.8以后ArrayList的默认容量为0.
如果ArrayList的默认容量为0,还可以添加数组吗?
当然可以,通过扩容机制可以扩充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(即初始状态),则通过
ensureExplicitCapacity()方法将ArrayList容量扩充为10(DEFAULT_CAPACITY)。
为什么无参构造函数对ArrayList容量的初始化改变了呢?
虽然jdk1.8中的ArrayList默认容量为0,但在jdk1.6的无参构造函数的ArrayList默认容量为10:
public ArrayList(){ this(10); }
个人认为,jdk1.8中延迟初始化ArrayList的实际容量,应该是考虑如果一开始就初始化为10,那么大小为1o的数组中存的全部是null,这种数组多了也会占用大量的
空间,所以这是为了节省不必要浪费的空间,体现了懒加载的思想。
怎样使用ArrayList?
既然我们已经知道了怎么去定义一个ArrayList,接下来就是要使用ArrayList了,而ArrayList提供了常见的方法有:add、addAll、set、get、remove、size、isEmpty等。
因为ArrayList的一些方法会涉及到数据位置的变换,为了更直观的感受这些变化,在这里我们来举个栗子:
ArrayList<String> arrayList = new ArrayList<>(); arrayList.add("吕布"); arrayList.add("貂蝉"); arrayList.add("董卓"); arrayList.add("刘备"); arrayList.add("赵云");
也就是说,elementData数组中有这些数据:
如果在这些人物中加入”曹操“,我们来看看这个操作在源码中是怎么样的过程:
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
首先,会先通过ensureCapacityInternal(size+1)检查elementData数组的容量是否充足,然后在将数据放入数组中,我们来看看ArrayList是怎么进行容量检查的。
ensureCapacityInternal()
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数组是不是空数组,如果是的话,将形参minCapacity赋值为10(DEFAULT_CAPACITY),然后进入ensureExplicitCapacity()方法。
private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }
此方法中的modCount变量是从AbstractList继承下来的,用于记录对ArrayList的对象操作的次数:
private transient int modCount=0;
可以看到当形参minCapacity的数值比当前的elementData数组的长度大,则要调用grow()方法进行扩容操作。
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); }
可以看到,扩容规则为“数组当前的容量+(数组当前的容量/2)”,即扩容后的数组容量为之前数组容量的1.5倍。当然,如果超过了最大值,在hugeCapacity()方法
中会对其进行处理。
private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }