ArrayList 源码分析

时间  2019-12-12
标签 arraylist 源码 分析 栏目 Java 繁體版
原文   原文链接

ArrayList 源码分析

前言

ArrayList 算是咱们开发中最常常用到的一个集合了，使用起来很方便，对于内部元素的随机访问很快。今天来分析下ArrayList 的源码，本次分析基于 Java1.8 。java

ArrayList 简介

先来看下 ArrayList 的 API 描述：数组

从描述里面来看，ArrayList 是继承于 AbstractList 的，而且实现了 Serializable, Cloneable, Iterable, Collection, List, RandomAccess 这些接口。安全

  • 实现了 Serializable 是序列化接口，所以它支持序列化，可以经过序列化传输。
  • 实现了 Cloneable 接口，能被克隆。
  • 实现了Iterable 接口，能够被迭代器遍历
  • 实现了 Collection ，拥有集合操做的方法
  • 实现了 List 接口，拥有增删改查等方法
  • 实现了 RandomAccess 随机访问接口，支持快速随机访问，实际上就是经过下标序号进行快速访问。

先大致了解下ArrayList 的特色，而后再从源码的角度去分析：dom

  1. ArrayList 底层是一个动态扩容的数组结构,初始容量为 10，每次容量不够的时候，扩容须要增长 1.5 倍的容量（大多数状况下是扩容 1.5 倍的，可是在使用 addAll 的时候，可能有例外。）
  2. ArrayList 容许存放重复数据，存储顺序按照元素的添加顺序，也容许多个 Null 存在。
  3. 底层使用 Arrays.copyOf 函数进行扩容，每次扩容都会产生新的数组，和数组中内容的拷贝，因此会耗费性能，因此在多增删的操做的状况可优先考虑 LinkedList。
  4. ArrayList 并非一个线程安全的集合。若是集合的增删操做须要保证线程的安全性，能够考虑使用 CopyOnWriteArrayList 或者使Collections.synchronizedList(List l) 函数返回一个线程安全的 ArrayList 类.

ArrayList 源码分析

一些属性

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // 序列化 ID
    private static final long serialVersionUID = 8683452581122892189L;

    /** * ArrayList 默认的数组容量 */
    private static final int DEFAULT_CAPACITY = 10;

    // 一个默认的空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 在调用无参构造方法的时候使用该数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

  
    // 存储 ArrayList 元素的数组
    // transient 关键字这里简单说一句，被它修饰的成员变量没法被 Serializable 序列化 
    transient Object[] elementData; // non-private to simplify nested class access

    // ArrayList 的大小，也就是 elementData 包含的元素个数
    private int size;
}
复制代码

构造方法

内部几个主要的属性就这些。再来看下构造方法：函数

// 指定大小的构造方法，若是传入的是 0 ，直接使用 EMPTY_ELEMENTDATA
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);
    }
}
// 调用该构造方法构造一个默认大小为 10 的数组，可是此时大小未指定，
// 仍是空的，在第一次 add 的时候指定
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 传入一个集合类
// 首先直接利用Collection.toArray()方法获得一个对象数组，并赋值给elementData 
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray 出错的时候，使用Arrays.copyOf 生成一个新数组赋值给 elementData
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        //若是集合c元素数量为0，则将空数组EMPTY_ELEMENTDATA赋值给elementData 
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
复制代码

能够看到，不论是调用哪一个构造方法，都会初始化内部 elementData 。源码分析

add 方法

接下来从最经常使用的 add 方法看起：性能

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
复制代码

执行 ensureCapacityInternal(size + 1) 确认内部容量this

private void ensureCapacityInternal(int minCapacity) {
    // 若是建立 ArrayList 时候，使用的无参的构造方法，那么就取默认容量 10 和最小须要的容量（当前 size + 1 ）中大的一个肯定须要的容量。
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}
复制代码

其实这里的 size 的默认值是 0 ，因此在使用默认构造方法建立 ArrayList 之后第一次执行 ensureCapacityInternal 的时候，要扩容的容量就是 DEFAULT_CAPACITY = 10；spa

private void ensureExplicitCapacity(int minCapacity) {
    // 修改 +1 
    modCount++;
    // 若是 minCapacity 比当前容量大， 就执行grow 扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // 拿到当前的容量
    int oldCapacity = elementData.length;
    // oldCapacity >> 1 意思就是 oldCapacity/2，因此新容量就是增长 1/2.
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 若是新容量小于，须要最小扩容的容量，以须要最小容量为准扩容
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 若是新容量大于容许的最大容量，则以 Inerger 的最大值进行扩容
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 使用 Arrays.copyOf 函数进行扩容。
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// 容许的最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}
复制代码

根据上面的代码能够看出，若是咱们默认扩容 1.5 倍的容量比最小须要的容量（minCapacity）还小，那么就使用 minCapacity 进行扩容。因此并非每次都是以 1.5 倍进行扩容的。线程

上面讲了扩容，扩容好了之后，就执行

elementData[size++] = e;
return true;
复制代码

进行赋值操做，就完成了一次数据的添加。

再来看下在指定位置添加一个元素:

public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
复制代码

先判断传入的位置是够越界。越界就抛出异常

而后确认需不须要扩容，而后再经过 System.arraycopy 方法进行拷贝。

须要注意的是 size - index 表示的是须要移动的元素的数量。也就是 index 后面的元素都要进行移动，这也就是插入效率低的一个缘由，在指定位置插入数据，那么这个位置后面的数据都要移动，若是是在第 0 个位置插入，意味着全部的元素都要移动。

上面的 add 方法分析完了，而后再来看下另外一个常见的 addAll 方法:

addAll 方法

先看第一个 addAll

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;
}
复制代码

这里也很简单，先转成数组，拿到长度进行扩容。而后利用 System.arraycopy 函数把传进来的数组拷贝到现有数组里面。

再来看第二个 addAll 方法:

这个是在指定位置添加一个集合。

public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(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;
}
复制代码

这里也很简单，基本和使用 add 方法在指定位置添加一个元素差很少。就不在分析了。接下来看看删除相关的。

remove 方法

看下源码：

删除一个指定位置的元素：

public E remove(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    modCount++;
    E oldValue = (E) 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;
}
复制代码

很简单，先判断是够越界，越界抛出异常。

而后先把要删除的元素拿出来，存储在 oldValue ，这里看到了一个 numMoved ，也就是删除一个元素须要移动的元素的数量。而后执行 System.arraycopy 进行数组的移动，这里只移动删除的 index 后面的元素，通通向前进一位。而后把数组中最后一个元素置为 null，返回删除的元素。

删除一个指定的元素：

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;
}

private void fastRemove(int index) {
    modCount++;
    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
}
复制代码

这里分两种状况，

  1. 删除的元素为 null ，根据循环查找到第一个为 null 的元素，而后执行 fastRemove(index) 删除以后，返回 true 删除成功，能够看到这里的 fastRemove 方法和 remove(int index) 是比较相似的，就不讲了。
  2. 删除的元素不为 null ，和为 null 逻辑差很少，就是对元素的判断不一样，这里使用的 o.equals(elementData[index])，而为 null 的时候，使用 elementData[index] == null

set 方法

set 方法就是在指定位置改变一个元素的值

public E set(int index, E element) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
}
复制代码

一样，先判断是否越界，越界抛出异常，没越界直接修改值，把旧值返回。

get 方法

取某个位置的元素：

public E get(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    return (E) elementData[index];
}
复制代码

一样，先判断是否越界，越界抛出异常，没越界属于数组的操做，直接返回指定位置的值。

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，可让 gc 回收，而后再把数组的长度置为 0 。下次 add 的时候，仍是直接扩容到长度为 10.

indexOf 方法

返回元素在集合中的位置

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;
}
复制代码

和 remove 的时候相似，分为两种状况处理。饭后返回元素在数组中的位置。

最后元素最后出现的位置

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;
}
复制代码

和 indexOf 操做同样，只不过是倒序查找第一个元素出现的位置

isEmpty 方法

是否为空

public boolean isEmpty() {
    return size == 0;
}
复制代码

能够看到是根据 size 来判断的，即便你把 ArrayList 中的每一个元素置为 null，可是 size 不为 0 的话，isEmpty 依旧返回 false。

总结

经过上面的分析能够再次总结下结论：

  1. ArrayList 底层是一个动态扩容的数组结构,初始容量为 10，每次容量不够的时候，扩容须要增长 1.5 倍的容量
  2. 增长（add）和删除（remove）操做会改变 modCount，可是查找（get）和修改（set）不会修改
  3. 从上面能够看出，增长和删除均可能涉及到扩容操做，扩容和删除会移动已有元素的位置，比较低效，可是查找和修改时很高效的。
  4. 从上面看出，ArrayList 对 null 元素是支持的，而且不会限制数量，也不会限制重复元素的增长
  5. 全文没见 Synchronized 关键字，也没有其它保证线程安全的操做，因此是线程不安全的，可使用CopyOnWriteArrayList 或者使Collections.synchronizedList(List l) 函数返回一个线程安全的 ArrayList 类来保证线程安全。

使用建议：

  • 若是是修改和获取操做比较多，建议使用 ArrayList ，效率高。
  • 若是增长和删除操做较多，建议使用 LinkedList（下篇分析），可是若是增长和删除的操做都在队尾，不涉及到元素的移动，仍是建议使用 ArrayList ，毕竟 ArrayList 的查找和修改的效率仍是蛮高的。
  • 使用的时候，若是肯定元素的大小，最好能设置下 ArrayList 的容量，避免扩容浪费空间

这篇就讲到这里，下篇来看下 LinkedList。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程