概述
一问到ArrayList,我们会简单的想到他的一些性质:动态数组(自动扩容);允许任何元素插入(包括null);初始化容量为10等等。
下面我们试着解析一下源码,探索一下 Java 是怎么实现 ArrayList 的。
因为会按功能去解析,所以下方类的顺序和源码中的不一定一致。
底层数据结构
/**
* 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 Object[] elementData; // non-private to simplify nested class access
可以看出 ArrayList 本质上是一个 object 类型的数组。object是所有类型的父类的,所以能插入任意元素也不足为奇了。
一些其他的参数
/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
size 就是获取ArrayList的大小(包含的元素数量),没什么讲的。
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
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 = {};
这两个参数很有意思,两个都是空数组,具体有什么区别呢。
EMPTY_ELEMENTDATA 的注释说的是用于空实例的共享空数组实例。
DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的注释说的是用于默认大小的空实例的共享空数组实例,与EMPTY_ELEMENTDATA区分,以了解添加第一个元素时扩容多少。
通过两个注释我们可以猜测:
- 无参构造,及new ArrayList<>() 的时候使用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA来初始化
- 有参构造,但是参数的值为0,比如new ArrayList<>(0) 的时候使用的是EMPTY_ELEMENTDATA来初始化
PS:elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA的时候会扩容为默认初始容量10,具体看后面的扩容方法。
构造函数
构造函数一
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
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);
}
}
该构造函数是一个有参构造,这里能明确看到,传入的initialCapacity大于0的时候,直接创建一个initialCapacity大小的Object数组。
如果initialCapacity的值为 0 的话,他使用的是EMPTY_ELEMENTDATA来初始化,这里也验证了我们上方的猜测。
构造函数二
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
构造函数为无参构造的时候,直接使用DEFAULTCAPACITY_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();
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;
}
}
这个构造函数也是一个有参构造,因为ArrayList实现了List接口,LIst接口又继承了Collection接口。并且Collection本身也是我们Java容器的顶层接口之一(另一个是Map,他俩都是继承的Iterable接口)。
所以ArrayList提供了将其他实现了Collection接口的类型通过迭代拿来使用的构造方法。
这个构造函数里面有一些不一样的东西,我们分析一下:
elementData = c.toArray();
toArray方法会被所有实现了Collection接口的类重写。
我们先看一个LinkedList的重写:
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
这里看出是通过迭代的方式拿出值,然后返回一个Object数组。
当然ArrayList本身也重写了这个方法,因为本身储存的就是Object数组,所以直接copy一份:
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
接下来的判断语句有点意思:
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;
}
else的语句没啥意义,就是获取的elementData长度为0,就用EMPTY_ELEMENTDATA初始化。
在if里面有一句注释 c.toArray might (incorrectly) not return Object[] (see 6260652) 。
这里我们可以问出两个问题:
- 为什么elementData(或者c.toArray)可能不是object数组类型的
- ArrayList什么时候会出现这种情况
1、为什么elementData可能不是object数组类型的
大家可能会想,为什么我的Collection接口写了返回类型是Object数组,子类重写也都是返回的Object数组,况且我接收数值的elementData也是Object数组,为什么还可能出现 c.toArray 不返回Object数组的情况呢。
这里我们先做个简单的测试:
ArrayList<Object> arrayList = new ArrayList<>();
System.out.println(arrayList.getClass());
-------输出结果----------
class java.util.ArrayList
这个代码大家肯定毋庸置疑的,能肯定 arrayList 的类型是 ArrayList。
那么我改成这样呢,用List类型去接收这个数组:
List<Object> list = new ArrayList<>();
System.out.println(list.getClass());
-------输出结果----------
class java.util.ArrayList
你会发现他还是ArrayList,是List的子类。
所以我们返回的Object数组,类别就真的是Object数组吗。
这里我们选择最直观的办法,就是我们直接实现List接口,重写toArray方法试试。
public class MyList implements List {
@Override
public Object[] toArray() {
return new String[]{"1", "2", "3"};
}
}
其他方法我这里没展示了,我们这里重写了toArray的无参方法,我给他return一个String数组。
然后写个测试类:
public class test {
public static void main(String[] args) {
MyList myList = new MyList();
System.out.println(myList.toArray().getClass());
Object[] objects = myList.toArray();
System.out.println(objects.getClass());
}
}
-----------输出结果-------------
class [Ljava.lang.String;
class [Ljava.lang.String;
你会发现我们toArray方法返回的并不是Object数组,就算用个Object数组去接收,他也不是Object数组。
我们就可以得到一个结论:一个变量的实际类别,可能是他的修饰类,也可能是修饰类的子类,得看他具体写入的类型是什么。
2、ArrayList什么时候会出现这种情况
我们先回忆一下List的创建方法,一般有两种:
List<Integer> list1 = Arrays.asList();
List<Integer> list2 = new ArrayList<>();
一种是使用了Arrays的静态方法asList,一种是使用ArrayList的构造方法。
我这里可以直接给大家答案,当使用**Arrays.asList()**创建的对象作为入参时,会出现 elementData 的类型不为 Object数组 的情况:
public class test {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3);
System.out.println(list1.getClass());
System.out.println(list1.toArray().getClass());
System.out.println(list1.toArray().getClass() == Object[].class);
System.out.println();
List<Integer> list2 = new ArrayList<>(list1);
System.out.println(list2.getClass());
System.out.println(list2.toArray().getClass());
System.out.println(list2.toArray().getClass() == Object[].class);
}
}
-----------输出结果----------
class java.util.Arrays$ArrayList
class [Ljava.lang.Integer;
false
class java.util.ArrayList
class [Ljava.lang.Object;
true
大家可以自己debug试一试。
我们这里打印了他们的情况,试着来分析一下原由。
这里我们可以看到两个list的类别有一点差别,list1 是 java.util.Arrays$ArrayList ,list2 是 java.util.ArrayList 。
也许这就是玄机所在,我们试着看看Arrays的源码。
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
首先是asList方法,里面是 new ArrayList<>(a),这里难道又回到我们一开始的构造函数了吗,我们点进去看看。
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
@Override
public int size() {
return a.length;
}
@Override
public Object[] toArray() {
return a.clone();
}
~~~~~~~~~略~~~~~~
}
你会发现在Arrays类里面居然还有一个也叫 ArrayList 的内部类。并且他的 toArray 方法只是做了一个浅克隆,所以我们传了一个Integer数组进去,当然就只会返回一个Integer数组。
这里我们的思路开始清晰起来了,我们走一下上面例子中 List list2 = new ArrayList<>(list1) 的执行流程。
- 将 java.util.Arrays$ArrayList 类型的 list1 作为入参,调用 java.util.ArrayList 的构造方法。
- 执行 c.toArray 方法时,调用 java.util.Arrays$ArrayList 中的 toArray 方法。
- 返回一个 Integer数组 类型回去。
- 命中 elementData.getClass() != Object[].class 判断。
最后:
大家细看 java.util.Arrays$ArrayList 类包含的方法,你会发现并没有 add/remove/clear 相关的方法。
所以这也是为什么使用 Arrays.asList() 创建的 List 使用 add/remove/clear 相关方法就会抛出 UnsupportedOperationException 异常的原因吧。
public class test {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3);
list1.add(4);
}
}
--------输出结果----------
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at test.main(test.java:10)