ArrayList源码解析一

hygge999

于 2022-07-14 17:54:38 发布

阅读量265

点赞数 1

分类专栏： # 集合文章标签： java jvm 算法

本文链接：https://blog.csdn.net/z55947810/article/details/125789778

版权

集合专栏收录该内容

5 篇文章 0 订阅

订阅专栏

概述

一问到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) 的执行流程。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-95nKeWIR-1657792303822)(C:\Users\NPC144\AppData\Roaming\Typora\typora-user-images\image-20220708164736886.png)]$

将 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)

hygge999

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ArrayList源码解析一

一问到ArrayList，我们会简单的想到他的一些性质：动态数组(自动扩容)；允许任何元素插入(包括null)；初始化容量为10等等。下面我们试着解析一下源码，探索一下 Java 是怎么实现 ArrayList 的。因为会按功能去解析，所以下方类的顺序和源码中的不一定一致。可以看出 ArrayList 本质上是一个 object 类型的数组。object是所有类型的父类的，所以能插入任意元素也不足为奇了。size 就是获取ArrayList的大小(包含的元素数量)，没什么讲的。DEFAULT_CAPA
复制链接

扫一扫

专栏目录