Java集合：ArrayList详解

最新推荐文章于 2022-02-10 18:19:12 发布

pre_tender

最新推荐文章于 2022-02-10 18:19:12 发布

阅读量466

点赞数

分类专栏：数据结构 Java

原文链接：https://blog.csdn.net/v123411739/article/details/79190114

版权

数据结构同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

Java

8 篇文章 0 订阅

订阅专栏

说明

本文主要参考自以下文章，包含内容的转载，在此先表示感谢：

概述

介绍数据结构----ArrayList。

1. ArrayList相关概念

ArrayList是我们日常中最常用的集合之一，在使用List时，除非特殊情况，我们一般都会选择使用ArrayList

1.1 基本概念

ArrayList是List接口的可变数组的实现。它实现了所有可选列表操作，并允许包括 null 在内的所有元素。
除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

List list = Collections.synchronizedList(new ArrayList(...));

1.2 容量

每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。

2. ArrayList相关源码解析

2.1 ArrayList的实现

对于ArrayList而言，它实现List接口、底层使用Object[]数组保存所有元素。其操作基本上是对Object[]数组的操作。其结构如下图所示：
在这里插入图片描述

2.1.1 基础属性

private static final int DEFAULT_CAPACITY = 10; // 初始容量10
 
private static final Object[] EMPTY_ELEMENTDATA = {};   // 空实例数组
 
// 默认大小的空实例数组，在第一次调用ensureCapacityInternal时会初始化长度为10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};   
 
transient Object[] elementData; // 存放元素的数组
 
private int size;   // 数组当前的元素数量

2.1.2 构造方法

ArrayList提供了三种构造器

方法	说明
`ArrayList()`	构造一个初始容量为 10 的空列表。
`ArrayList(`Collection c`)`	构造一个包含指定 collection 的元素的列表。这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
`ArrayList(`int initialCapacity`)`	构造一个具有指定初始容量的空列表。

public ArrayList() {    // 不带容量参数则使用默认大小的空实例数组
    this.elementData = DEFAULTCAPACITY_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);
    }
}

2.2 get()

由于底层是数组实现的:

先检查下索引是否越界
然后直接返回对应索引位置的元素。

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}
 
/**
 * Returns the element at the specified position in this list.
 *
 * @param  index index of the element to return
 * @return the element at the specified position in this list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E get(int index) {   // 根据索引获取元素
    rangeCheck(index);  // 校验索引是否越界
 
    return elementData(index);  // 直接根据index返回对应位置的元素（底层elementData是个数组）
}

2.3 set()

校验索引是否越界
根据index获取指定位置的元素
用传入的element替换index位置的元素
返回index位置原来的元素

public E set(int index, E element) {    // 用指定的元素（element）替换指定位置（index）的元素
    rangeCheck(index);  // 校验索引是否越界
 
    E oldValue = elementData(index);    // 根据index获取指定位置的元素
    elementData[index] = element;   // 用传入的element替换index位置的元素
    return oldValue;    // 返回index位置原来的元素
}

2.4 add()

2.4.1 数组尾部添加

add(E e)：

调用ensureCapacityInternal方法，将modCount+1，并校验添加元素后是否需要扩容。
在elementData数组尾部添加元素即可（size位置）。

/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) {   // 增加一个元素
    ensureCapacityInternal(size + 1);  // 将modCount+1，并校验添加元素后是否需要扩容
    elementData[size++] = e;    // 在数组尾部添加元素，并将size+1
    return true;
}

2.4.2 指定索引添加

add(int index, E element)：

检查索引是否越界，再调用ensureCapacityInternal方法，将modCount+1，并校验添加元素后是否需要扩容。
将index位置及之后的所有元素向右移动一个位置（为要添加的元素腾出1个位置）。
将index位置设置为element元素，将size+1。

添加过程如图：
在这里插入图片描述

/**
 * 将指定的元素（element）插入此列表中的指定位置（index）。
 * 		然后将index位置及后面的所有元素（如果有的话）向右移动一个位置
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);    // 校验索引是否越界
 
    ensureCapacityInternal(size + 1);  // 将modCount+1，并校验添加元素后是否需要扩容
    System.arraycopy(elementData, index, elementData, index + 1,    // 将index位置及之后的所有元素向右移动一个位置（为要添加的元素腾出1个位置）
                     size - index);
    elementData[index] = element;   // index位置设置为element元素
    size++; // 元素数量+1
}

2.5 remove()

2.5.1 指定索引移除

remove(int index)：

检查索引是否越界，将modCount+1，拿到索引位置index的原元素。
计算需要移动的元素个数。
如果需要移动，将index+1位置及之后的所有元素，向左移动一个位置。
将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）

remove(int index)方法的过程如下图所示:
在这里插入图片描述

public E remove(int index) {    // 删除列表中index位置的元素，将index位置后面的所有元素向左移一个位置
    rangeCheck(index);  // 校验索引是否越界
 
    modCount++; // 修改次数+1
    E oldValue = elementData(index);    // index位置的元素，也就是将要被移除的元素
 
    int numMoved = size - index - 1;    // 计算需要移动的元素个数，例如：size为10，index为9，此时numMoved为0，则无需移动元素，因为此时index为9的元素刚好是最后一个元素，直接执行下面的代码，将索引为9的元素赋值为空即可
    if (numMoved > 0)   // 如果需要移动元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved); // 将index+1位置及之后的所有元素，向左移动一个位置
    elementData[--size] = null; // 将size-1，并将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）
 
    return oldValue;    // 返回index位置原来的元素
}

2.5.2 指定元素移除

fastRemove(int index)：跟remove(int index)类似，私有方法，供下面面的remove方法调用，直接删除掉index位置的元素

将modCount+1，并计算需要移动的元素个数。
如果需要移动，将index+1位置及之后的所有元素，向左移动一个位置。
将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）。

remove(Object o)：

如果入参元素为空，则遍历数组查找是否存在元素为空，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功。
如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功。
否则，不存在目标元素，则返回false。

public boolean remove(Object o) {   // 如果存在与入参相同的元素，则从该列表中删除指定元素的第一个匹配项。如果列表不包含元素，则不变
    if (o == null) {    // 如果入参元素为空，则遍历数组查找是否存在元素为空，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {    // 如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;   // 不存在目标元素，返回false
}
 
/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {    // 私有方法，供上面的remove方法调用，直接删除掉index位置的元素
    modCount++; // 修改次数+1
    int numMoved = size - index - 1; // 计算需要移动的元素个数，例如：size为10，index为9，此时numMoved为0，则无需移动元素，因为此时index为9的元素刚好是最后一个元素，直接执行下面的代码，将索引为9的元素赋值为空即可
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved); // 将index+1位置及之后的所有元素，向左移动一个位置
    elementData[--size] = null; // 将size-1，并将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）
}

2.6 clear()

遍历数组将所有元素清空即可。

/**
 * Removes all of the elements from this list.  The list will
 * be empty after this call returns.
 */
public void clear() {   // 删除此列表中的所有元素。
    modCount++; // 修改次数+1
 
    // clear to let GC do its work
    for (int i = 0; i < size; i++)  // 遍历数组将所有元素清空
        elementData[i] = null;
 
    size = 0;   // 元素数量赋0
}

2.7 扩容

上文add方法在添加元素之前会先调用ensureCapacityInternal方法，主要是有两个目的：1.如果没初始化则进行初始化；2.校验添加元素后是否需要扩容。

2.7.1 设置初始数组容量

ensureCapacityInternal()：

此方法就是为默认大小的空实例数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA而写的，主要是给DEFAULTCAPACITY_EMPTY_ELEMENTDATA设置初始容量：
校验当前数组是否为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
如果是则将minCapacity设为DEFAULT_CAPACITY，

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
 
    ensureExplicitCapacity(minCapacity);
}

2.7.2 检查容量是否足够

ensureExplicitCapacity():

将modCount+1
并校验minCapacity是否大于当前数组的容量，如果大于则调用grow方法进行扩容。

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 修改次数+1
 
    // 如果添加该元素后的大小超过数组大小，则进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  // 进行扩容
}

2.7.3 grow()

grow(int minCapacity)：

将数组新容量设置为老容量的1.5倍。
两个if判断，第一个是对DEFAULTCAPACITY_EMPTY_ELEMENTDATA初始化的兼容，第二个是对超过MAX_ARRAY_SIZE的兼容。
调用Arrays.copyOf方法创建长度为newCapacity的新数组，并将老数组的数据复制给新数组，并将elementData赋值为新数组。

扩容过程如下：
在这里插入图片描述

// 数组允许的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; 
 
private void grow(int minCapacity) {    // 数组扩容
    // overflow-conscious code
    int oldCapacity = elementData.length;   // 原来的容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量 = 老容量 + 老容量 / 2
    if (newCapacity - minCapacity < 0)  // 如果新容量比minCapacity小，
        newCapacity = minCapacity;  // 则将新容量设为minCapacity，兼容初始化情况
    if (newCapacity - MAX_ARRAY_SIZE > 0)   // 如果新容量比最大允许容量大，
        newCapacity = hugeCapacity(minCapacity);    // 则调用hugeCapacity方法设置一个合适的容量
    // 将原数组元素拷贝到一个容量为newCapacity的新数组（使用System.arraycopy），
    // 并且将elementData设置为新数组
    elementData = Arrays.copyOf(elementData, newCapacity);  
}
 
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();   // 越界
    // 如果minCapacity大于MAX_ARRAY_SIZE，则返回Integer.MAX_VALUE，否则返回MAX_ARRAY_SIZE
    return (minCapacity > MAX_ARRAY_SIZE) ? 
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

ArrayList和LinkedList比较

主要是数组和链表的区别，访问、插入、删除等方面的区别。
在这里面，涉及的是寻址开销、复制开销、内存占用等方面的问题

LinkedList详解可以看我的另一篇文章：Java集合：LinkedList详解

ArrayList底层基于动态数组实现(扩容1.5倍，拷贝数组)，LinkedList底层基于链表实现
对于随机访问（get/set方法），ArrayList通过index直接定位到数组对应位置的节点，而LinkedList需要从头结点或尾节点开始遍历，直到寻找到目标节点，因此在效率上ArrayList优于LinkedList
对于插入和删除（add/remove方法），ArrayList需要移动目标节点后面的节点（使用System.arraycopy方法移动节点），而LinkedList只需修改目标节点前后节点的next或prev属性即可，因此在效率上LinkedList优于ArrayList。（然而对于插入和删除来说，首先是需要进行查找操作，大体上相当于随机访问，那么如果考虑到这部分，LinkedList未必就优于ArrayList。因此，在选择上，如果你是插入，需要综合考虑再选择）
从内存的角度来说，LinkedList更适用于存储较少元素。因为LinkedList里面不仅维护了待插入的元素，还维护了Node的前置Node和后继Node，如果一个LinkedList中的Node非常多，那么LinkedList将比ArrayList更耗费一些内存；并且在访问上，太多的元素会导致查找效率低下。

二者如何选择？

元素较少，优先LinkedList；
插入和删除较频繁，优先LinkedList；
访问较为频繁，优先ArrayList；
访问、插入、删除均频繁，取决于元素数量和实际情况；
内存角度来说，ArrayList在插入删除中移动元素，那么会有大量的复制内存开销；LinkedList则需要保存很对的prev和next，较为耗费内存；
总体来说，需要考虑实际情况。例如插入来说，假设一直是尾插，那么实际上ArrayList的效率并不见得低于LinkedList，反而LinkedList一直需要修改并保存新的结点指向，效率低些。

总结

介绍了ArrayList的基本原理，并介绍了其构造方法和提供的操作，最后对比了LinkedList。

pre_tender

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java集合：ArrayList详解

说明本文主要参考自以下文章，包含内容的转载，在此先表示感谢：深入学习java8集合（一）：ArrayList的实现原理Java集合：ArrayList详解文章目录说明概述1. ArrayList相关概念1.1 基本概念1.2 容量2. ArrayList相关源码解析2.1 ArrayList的实现2.1.1 基础属性2.1.2 构造方法2.2 get()2.3 set()2....
复制链接

扫一扫