ArrayList源码解析

最新推荐文章于 2024-08-22 16:13:15 发布
最新推荐文章于 2024-08-22 16:13:15 发布
阅读量493 收藏
点赞数
分类专栏： Java集合容器源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tangyuan_sibal/article/details/89762578
版权

文章目录

1、ArrayList类的说明

本篇分析ArrayList的源码，在分析之前先跟大家谈一谈数组。数组可能是我们最早接触到的数据结构之一，它是在内存中划分出一块连续的地址空间用来进行元素的存储，由于它直接操作内存，所以数组的性能要比集合类更好一些，这是使用数组的一大优势。但是我们知道数组存在致命的缺陷，就是在初始化时必须指定数组大小，并且在后续操作中不能再更改数组的大小。在实际情况中我们遇到更多的是一开始并不知道要存放多少元素，而是希望容器能够自动的扩展它自身的容量以便能够存放更多的元素。ArrayList就能够很好的满足这样的需求，它能够自动扩展大小以适应存储元素的不断增加。它的底层是基于数组实现的，因此它具有数组的一些特点，例如查找修改快而插入删除慢。本篇我们将深入源码看看它是怎样对数组进行封装的。首先看看它的成员变量和三个主要的构造器。-------转自 https://www.cnblogs.com/liuyun1995/p/8286829.html

1.1 解释说明
 * 可变数组(ArrayList)实现了List的接口.  实现了所有List的操作，和允许所有类型的元素，包括
 * 空值，除了实现List接口之外，这个类还提供了操作数组大小(size)这个作为一个元素
 * 存储在数组内部。这个数组粗略(roughly)的等同于Vecotr，除了ArrayList不保证线程
 * 安全,(当然了还有扩容的方式，ArrayList是1.5倍，Vertor是2倍)
 * 
 * 
 * ArrayList中的size()计算元素个数,isEmpty()判断数组是否为空，get()获取元素,set()
 * 修改元素，iterator()迭代这些操作都是常量O(1)的时间复杂度。而add()增加操作是
 * 平均时间复杂度(amortized constant time),换言之，增加一个元素需要O(n)时间复杂度
 * 一般来说，所有的其他操作都是线性的时间复杂度。这个算法的常量因子(constant factor)
 * 低于LinkedList的。
 * 
 * 
 * 每一个ArrayList都有一个容量。这个容量时数组的用于存储元素于数组的大小。它总是
 * 至少与数组元素个数大小相等。当元素被加入ArrayList,这个容量是会增长的。这个容量
 * 扩容的方法的平均时间复杂度没有比增加一个元素还复杂。
 * 
 * 
 * 可以应用ensureCapacity()方法来对数组扩容当要加入大量的元素的时候，这样可以减少
 * 因为增加元素而重分配的次数。(也就是说最好一开始确定好所需要的容量大小)
 *
 *
 * 需要注意的是这个方法不是同步的方法，需要同步的应用(copyonwriteArrayList),如果多个
 * 线程同时操作ArrayList实例和至少有一个线程修改list的结构,必须在外部加同步操作。关于
 * 结构性操作可以看前面的HashMap的介绍。这个同步操作通常是压缩在某些对象头上面。(synchronized
 * 就是存储在对象头上面。)
 * 
 * 
 * 如果对象头不存在这样的对象，这个列表应该使用{@link Collections#synchronizedList Collections.synchronizedList}工具
 * 来封装，这个操作最好是在创建List之前完成，防止非同步的操作。
 * List list = Collections.synchronizedList(new ArrayList(...));
 * 但是一般不用这个方法，而是用JUC包下的CopyOnWriteArrayList更加高效。
 * 
 * 
 * 快速失败机制(...好像在集合容器下面都有这个机制来抛出异常...)
 * 当一个list被多个线程成同时修改的时候会抛出异常。但是不能用来保证线程安全。
 * 所以在多线程环境下，还是要自己加锁或者采用JUC包下面的方法来保证线程安全，
 * 而不能依靠fail-fast机制抛出异常，这个方法只是用来检测bug。
1.2 数据结构

在这里插入图片描述
ArrayList大概可以用这张图来描述，主要是一个ArrayList实例，里面封装着一个elementdata数组。其中有一个size字段，每次增加一个元素的时候就加1，删除就减1。这样当需要获取数组长度的时候，就可以在时间复杂度为O(1)下。

2、方法字段

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

    /**
     * 默认初始容量为10，Vector也是10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 共享空对象数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
	-* 默认的空对象数组，以此来区分当添加第一个元素的时候，数组是怎么样膨胀的
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
    * 存储ArrayList元素的数组缓冲区。
	* ArrayList的容量是这个数组缓冲区的长度。任何
	* 使用elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA清空ArrayList
	* 将在添加第一个元素时扩展为DEFAULT_CAPACITY。
    */
    //内部封装的数组
    transient Object[] elementData; // 非私有来简化嵌套类的访问

    /**
     * ArrayList中的元素个数
     */
    private int size;
    .
    .
    .
   /**
     * 能分配的最大数组大小，因为有些数组会在头分配一下信息，
	 * 所以要注意这里的最大大小是Integer.MAX_VALUE - 8。
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    .
    .
    .
    /*
	 * 多线程环境下，当涉及到结构性修改(add,remove)时，用modCount来判断是否会有多个线程同时修改，
	 * 当modeCount不是期望值时候，抛出异常
	 * fail-fast
	 */
    
    protected transient int modCount = 0;
}

ArrayList的方法字段比较少，主要的是 private static final int DEFAULT_CAPACITY = 10;,初始化默认为10的容量大小。还有两个默认的空数组。另外两个就是前面提到。

3、主要方法

构造函数

   /**
     * 构造具有初始容量的空数组
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];//当给出初始容量且初始容量大于0时，用初始容量来初始化
        } else if (initialCapacity == 0) {//当给出的默认容量为0时，则构造一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//当给出的是小于0的，则抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }



    /**
     * 如果没有给初始容量，则初始化一个大小为10的默认容量
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }


    /**
	 * 当传入一个数组的时候，则将这个数组包装成ArrayList，并返回这个数组的迭代顺序
     */
    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);//将数组赋值到ArrayList
        } else {
            // 如果传入的是一个空数组，则构造一个空的对象
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList的构造函数主要有3种，一种是传入初始容量的，采用默认的，还有就是传入一个数组，以这个数组的大小为容量，里面的元素进行初始化。

trimToSize()

    /**
     *将ArrayList大小修改为元素个数的大小。
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

  /**
     * ArrayList扩容
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//获取原始数组大小
        int newCapacity = oldCapacity + (oldCapacity >> 1);//关键是这一句，1.5倍的扩容
        if (newCapacity - minCapacity < 0)//检查数组是否小于最小容量
            newCapacity = minCapacity;//设置为最小容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)//大于最大容量
            newCapacity = hugeCapacity(minCapacity);//设置为最大容量
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//拷贝原来的数组到新的数组
    }

size(),isEmpty()

    /**
     * 返回当前ArrayList中的元素个数
     *
     */
    public int size() {
        return size;
    }

    /**
     * 返回是否包含元素
     *
     */
    public boolean isEmpty() {
        return size == 0;
    }

indexOf(Object o)

    /**
     * 返回第一次出现该元素的下标，如果不存在则返回-1
     */
    public int indexOf(Object o) {
        if (o == null) {//如果对象为空，因为ArrayList允许空对象，所以查找到第一个为空的
            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;//找不到，返回-1
    }

lastIndexOf(Object o)

    /**
     * 返回最后一次出现的index，不存在则返回-1
     * 与indexOf一样，只不过是从后往前面扫描
     */
    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;
    }

get() set() add(E e)

    // 返回指定位置的元素

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 获取指定下标的元素
     */
    public E get(int index) {
        rangeCheck(index);//检查下标是否合法

        return elementData(index);//返回相应下标的元素
    }

    /**
     * 设置指定下标的元素为新值
     */
    public E set(int index, E element) {
        rangeCheck(index);//检查下标是否合法

        E oldValue = elementData(index);//获取相应下标的旧值
        elementData[index] = element;//设置为新值
        return oldValue;//返回旧值
    }

    /**
     *增加元素，没有指定下标则在最后添加
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 涉及到结构性修改，modcount++,
        elementData[size++] = e;//在末尾追加元素
        return true;
    }

add(int index, E element)

   /**
     * 插入元素至指定位置
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // 涉及到结构性修改，modcount++
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//元素后移，实际是复制到另外一个数组中，只不过这里的数组是原数组
        elementData[index] = element;//添加元素
        size++;//数组中元素个数加1
    }

remove()


    /**
     * 删除指定下标元素
     */
    public E remove(int index) {
        rangeCheck(index);//检查数组下标是否合法

        modCount++;// 涉及到结构性修改，modcount++
        E oldValue = elementData(index);//获取下标值

        int numMoved = size - index - 1;
        if (numMoved > 0)//元素前移，实际上就是一个元素复制覆盖的过程
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // 将最后一个元素置空，以便回收

        return oldValue;
    }

    /**
     * 删除第一次出现的元素，成功则返回true，否则返回false
     */
    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
    }

4、总结

每次添加元素前会调用ensureCapacityInternal这个方法进行集合容量检查。在这个方法内部会检查当前集合的内部数组是否还是个空数组，如果是就新建默认大小为10的Object数组。如果不是则证明当前集合已经被初始化过，那么就调用ensureExplicitCapacity方法检查当前数组的容量是否满足这个最小所需容量，不满足的话就调用grow方法进行扩容。在grow方法内部可以看到，每次扩容都是增加原来数组长度的一半，扩容实际上是新建一个容量更大的数组，将原先数组的元素全部复制到新的数组上，然后再抛弃原先的数组转而使用新的数组。至此，我们对ArrayList中比较常用的方法做了分析，其中有些值得注意的要点：

  1. ArrayList底层实现是基于数组的，因此对指定下标的查找和修改比较快，但是删除和插入操作比较慢。
  2. 构造ArrayList时尽量指定容量，减少扩容时带来的数组复制操作，如果不知道大小可以赋值为默认容量10。
  3. 每次添加元素之前会检查是否需要扩容，每次扩容都是增加原有容量的一半。
  4. 每次对下标的操作都会进行安全性检查，如果出现数组越界就立即抛出异常。
  5. ArrayList的所有方法都没有进行同步，因此它不是线程安全的。
  6. 以上分析基于JDK1.8，其他版本会有些出入，因此不能一概而论。
tangyuan_sibal
关注
专栏目录
JavaSE基础知识(二十一)--Java集合(容器)之类ArrayList的源码分析
ruidianbaihuo的博客
11-25 470
Java SE 是什么，包括哪些内容(二十一)？ 本文内容参考自Java8标准 再次感谢Java编程思想对本文的启发！ 前面的博文从概念性的角度分析了集合(容器)的功能作用，现在，再从顶层设计到底层设计(具体的实现类)的具体源码实现来继续分析集合(容器)。 上一篇博文已经详细了解了列表的根接口List，下面来详细了解一下有序集合(容器)，也就是列表的一个常用实现类： ArrayList(它的底层实...
ArrayList 源码解析
weixin_50837529的博客
08-05 225
首先因为调用了 add 方法，因此的话就将 modCount++ 变为 1，这个 modCount 是继承自 abstractList 的属性，然后在这个函数内存继续调用 add() 的重载方法，传入三个参数，一个是当前添加的元素的值，一个是当前的 Array List 中存数据的缓冲区，一个是当前容器的容量。容量是用于存储列表中的元素的数组的大小。这段话的意思是，ArrayList 实现了 List 接口，是一个可以调整的数组，可以存储任意类型的数据，包括 null 值，和操作数组的时间复杂度类似（...
Java 集合—— ArrayList 源码分析
最新发布
weixin_44814196的博客
08-22 867
分析 ArrayList 的底层数据结构和扩容机制。
第二章 ArrayList源码解析1
08-04
第二章 ArrayList源码解析 ArrayList是Java集合框架中的一种动态数组，它继承自AbstractList，并实现了List接口。ArrayList主要用于存储可变大小的对象列表，它的核心是通过一个Object类型的数组elementData来实现...
Java 集合框架(2-9)-Collection - ArrayList 源码解析.pdf
07-03
《Java集合框架(2-9)-Collection - ArrayList 源码解析》 ArrayList是Java集合框架中的一个重要组件，它属于List接口的实现类，提供了一种动态数组的逻辑视图。ArrayList以高效、灵活的方式存储和操作对象序列，是...
ArrayList 源码深度解析
01-20
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，...
arraylist 源码解析
06-10
ArrayList是Java集合框架中的一个类，它实现了List接口，可以用来存储一组对象，这些对象可以是任意类型。 下面是ArrayList的源码解析： 1. 成员变量 ```java /** * Default initial capacity. */ private static final int 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 = {}; /** * 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 /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size; ``` ArrayList有三个成员变量，分别是DEFAULT_CAPACITY、EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA。DEFAULT_CAPACITY表示默认的容量大小，EMPTY_ELEMENTDATA是一个空数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA也是一个空数组，但它会在第一次添加元素时扩容为DEFAULT_CAPACITY大小。elementData是一个Object类型的数组，用于存储ArrayList中的元素，size表示ArrayList中元素的数量。 2. 构造方法 ```java /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.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) { // defend against c.toArray (incorrectly) not returning Object[] // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } } /** * 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); } } ``` ArrayList提供了三个构造方法。第一个构造方法是无参的构造方法，它将elementData赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。第二个构造方法接收一个Collection类型的参数c，它将参数c中的元素转为数组并将其赋值给elementData。第三个构造方法接收一个int类型的参数initialCapacity，它根据参数initialCapacity的值创建一个Object类型的数组并将其赋值给elementData。 3. 常用方法 常用方法包括add()、get()、set()、remove()、size()等。 add()方法用于在ArrayList中添加一个元素，如果elementData的容量不足，就需要进行扩容。扩容的方式是将elementData数组的大小增加50%。 get()方法用于获取ArrayList中指定位置的元素。 set()方法用于将ArrayList中指定位置的元素替换为指定的元素。 remove()方法用于删除ArrayList中指定位置的元素。 size()方法用于获取ArrayList中元素的数量。 4. 总结 ArrayList是Java集合框架中的一个类，它实现了List接口，可以用来存储一组对象。ArrayList的源码解析包括成员变量、构造方法和常用方法。掌握ArrayList的源码可以帮助我们更好地理解它的实现原理，从而更加灵活地应用它。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值