Java | ArrayList源码分析

最新推荐文章于 2023-12-23 03:29:46 发布

chongyucaiyan

最新推荐文章于 2023-12-23 03:29:46 发布

阅读量2.7k

点赞数 1

分类专栏： Java源码文章标签： java

本文链接：https://blog.csdn.net/u012317510/article/details/84076244

版权

Java源码专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言

ArrayList类是List接口的一种实现，它表示一个列表。ArrayList是基于数组实现的，当数组容量不足时，会对数组进行扩容。Vector类也是List接口的一种实现，它也是基于数组实现的。ArrayList与Vector互相兼容，但是ArrayList是非线程安全的。

源码分析

定义

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    ...
}

ArrayList类继承于AbstractList类。AbstractList类提供了List接口的一个框架实现，以最小化实现这个支持“随机访问”数据存储（例如数组）的接口所需的工作量。

ArrayList类实现了4个接口：

List 列表接口，提供了操作列表的一系列方法，例如：add()、remove()、set()、get()等方法。
RandomAccess 随机访问标记接口，表示对象支持快速地随机访问。
Cloneable 可克隆标记接口，表示对象可以被克隆。
Serializable 序列化标记接口，表示对象可以被序列化。

主要变量

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData;

private int size;

其中：

DEFAULT_CAPACITY 默认的初始容量。
EMPTY_ELEMENTDATA 使用非默认构造方法构造ArrayList时，如果容量为0，那么elementData变量会被赋值为该值。
DEFAULTCAPACITY_EMPTY_ELEMENTDATA 使用默认构造方法构造ArrayList时，elementData变量会被赋值为该值。
elementData 用来存储列表元素。elementData数组是一个动态的数组，当存储容量不足时，会对它进行扩容。
size 列表中包含的元素的个数。

构造方法

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

默认构造方法构造了一个空列表。它将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData数组。当添加第一个元素时，elementData数组将被扩容为默认的初始容量DEFAULT_CAPACITY (10)。

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

该构造方法构造了一个指定了初始容量的空列表。指定一个合适的初始容量可以减少甚至避免数组的扩容。当指定的初始容量为0时，elementData数组被赋值为EMPTY_ELEMENTDATA，以区别于使用默认构造方法的情况。

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

该构造方法构造了一个包含了指定集合元素的列表。

add()方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

该add()方法将指定的元素添加到列表的末尾。首先调用ensureCapacityInternal()方法确保elementData数组的容量足够。然后将元素添加到数组的末尾并更新size变量。可以看出add()方法是支持null元素和重复元素的。接着来看ensureCapacityInternal()方法：

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

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

ensureCapacityInternal()方法首先确定了一个最小容量。然后调用ensureExplicitCapacity()方法来决定是否需要扩容。如果是使用默认构造方法构造的列表，当添加第一个元素的时候，会将最小容量设置为默认的初始容量DEFAULT_CAPACITY (10)。当确定的最小容量大于当前elementData数组的容量时，需要调用grow()方法进行扩容。接着来看grow()方法：

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);

    elementData = Arrays.copyOf(elementData, newCapacity);
}

grow()方法进行了真正的扩容操作。首先确定了扩容之后的容量大小。默认情况下，扩容之后的新容量是旧容量的1.5倍。当新容量比最小容量还小时，新容量为最小容量。最后调用Arrays类的copyOf静态方法完成新建数组，拷贝旧数组中的元素到新数组，并将新数组赋值给elementData变量。

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

该add()方法将指定的元素添加到列表中指定的位置。首先调用rangeCheckForAdd()方法检查指定的位置索引的合法性。然后调用ensureCapacityInternal()方法来确保elementData数组的容量足够。接着调用System类的arraycopy静态方法将elementData数组空出一个指定的位置。最后将指定的元素添加到指定的位置。

remove()方法

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = 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;
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

E elementData(int index) {
    return (E) elementData[index];
}

该remove()方法删除列表中指定位置的元素。首先调用rangeCheck()方法检查指定的位置索引的合法性。然后调用elementData()方法取出指定位置的旧元素。如果指定的位置不是最后一个元素的位置，那么需要调用System类的arraycopy静态方法完成删除指定位置的元素的操作。接着需要将最后一个元素设置为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
}

该remove()方法删除列表中第一个与指定元素相等的元素。如果列表中不包含与指定元素相等的元素，那么列表保持不变。remove()方法循环遍历elementData数组，查找第一个与指定元素相等的元素。如果找到，那么调用fastRemove()方法将该元素删除。

set()方法

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

E elementData(int index) {
    return (E) elementData[index];
}

set()方法将列表中指定位置的元素替换为指定的元素。首先调用rangeCheck()方法检查指定的位置索引的合法性。然后调用elementData()方法取出指定位置的旧元素。接着将指定位置的元素替换为指定的新元素。最后返回旧元素。

get()方法

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

get()方法返回列表中指定位置的元素。首先调用rangeCheck()方法检查指定的位置索引的合法性。然后调用elementData()方法直接返回指定位置的数组元素。

总结

ArrayList是基于Object数组实现的。该数组是一个动态的数组，当存储容量不足时，会进行扩容。
ArrayList在添加元素之前会检查数组的容量。如果容量不足，那么先进行扩容。默认情况下，新数组的容量为旧数组的1.5倍。
ArrayList在查找元素时，可以通过索引直接查找到元素，因此查找元素效率高。
ArrayList在列表中间插入或者删除元素时，需要移动元素，因此插入或者删除元素效率低。
ArrayList按照添加元素的顺序存储元素。
ArrayList允许元素为null。
ArrayList允许元素重复。
ArrayList是非线程安全的。

参考

https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

chongyucaiyan

关注

1
点赞
踩
1

收藏

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

前言ArrayList类是List接口的一种实现，它表示一个列表。ArrayList是基于数组实现的，当数组容量不足时，会对数组进行扩容。Vector类也是List接口的一种实现，它也是基于数组实现的。ArrayList与Vector互相兼容，但是ArrayList是非线程安全的。源码分析定义public class ArrayList&amp;amp;lt;E&amp;amp;gt; extends AbstractL...
复制链接

扫一扫