多图深度解析ArrayList源码

已于 2022-09-15 21:16:07 修改
阅读量808 收藏 4
点赞数 1
分类专栏： Java 文章标签： java 开发语言
于 2022-09-15 21:10:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oschina_41731918/article/details/126840316
版权
本文详细解析了ArrayList的内部实现，包括其特性、存储结构、使用示例、类关系、扩容机制以及常见操作。重点讨论了如何在添加元素时自动扩容，以及在开发中如何有效地利用ArrayList提高性能。同时，文章介绍了ArrayList的Fail-Fast机制，确保在并发修改时的正确性。
摘要由CSDN通过智能技术生成

文章目录

1. 概述

ArrayList 可以说是实际开发过程中使用最多的数据结构，我们有必要深究其原理，以便更好的提升它的效率。

1.1 特性

  • 顺序容器：写入和读出的顺序是一致的
  • 允许存储重复值，允许你存储null值
  • 容量不足时，容器会自动增大底层数组的大小

1.2 存储结构

在这里插入图片描述

2. 使用

2.1 代码

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.ArrayList;
import java.util.Arrays;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ArrayListTest {
    @Test
    public void test() {
        ArrayList<Integer> arr = new ArrayList<>();
		// size()获取到的是元素的个数
        System.out.println("默认大小： " + arr.size());

        arr.add(1);
        arr.add(2);
        arr.add(1);
        arr.addAll(Arrays.asList(5, 6));

        System.out.println("写入之后的大小： " + arr.size());
    }
}

2.2 输出

默认大小： 0
写入之后的大小： 5

3. 类关系

3.1 UML类图

在这里插入图片描述

4. ArrayList的实现

4.1 类属性

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

    /**
     * 多个空 ArrayList实例之间共享的 空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 将其与 EMPTY_ELEMENTDATA 区分开来，以便知道添加第一个元素时扩充多少
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 当 elementData  添加了第一个元素之后，容量就会被扩充到 DEFAULT_CAPACITY （10）个
 	 *
	 *	transient作用：不让elementData被序列化
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList 的大小（实际存储的元素个数）
     */
    private int size;

4.2 构造方法

	/**
     * 指定容量
     *
     */
    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
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 传入集合，可初始化元素
     */
    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 {
            // 使用空数组代替
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

5. 扩容机制

5.1 自动扩容

有一下两要点：

  • 每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容
  • 在实际添加大量元素前，我也可以使用ensureCapacity来手动增加ArrayList实例的容量，以减少递增式再分配的数量

使用时候注意：

  1. 当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量
  2. 根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量。
	/**
     * @param   minCapacity   期望的最小容量
     */
    public void ensureCapacity(int minCapacity) {
    	// 从当前的元素中，计算最小的扩展个数
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // 不是空数组（说明已经有元素了），就先不扩展
            ? 0
            // 元素个数为10
            : DEFAULT_CAPACITY;
		// 要扩展的容量多于最小扩展量才进行扩展
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
	
	/**
	* 计算最小容量
	*/
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

	/**
	* 当最小容量大于当前元素大小时，进行扩容
	*/
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * ArrayList的最多元素个数  2147483639
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
	 * 扩充容量，确保数组能够至少可存 minCapacity 个元素
     */
    private void grow(int minCapacity) {
        // 数组原始个数
        int oldCapacity = elementData.length;
        /**
        * 比如原始 oldCapacity == 10（二进制为 1010）
        * 1010 >> 1 等价于 0101 （十进制为5）；PS: 整数进行位右移相当于除以2
        * 那么新的容量就是 10 + 5 = 15；相当于1.5倍扩充
        */
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

	/**
	* 确保最大容量也只能是 MAX_ARRAY_SIZE 值
	*/
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

以上逻辑可以展示为如图所示：
在这里插入图片描述

5.2 添加单个元素

  • add(E e)
  • add(int index, E element)

这两个方法都是向容器中添加新元素，这可能会导致capacity不足，因此在添加元素之前，都需要进行剩余空间检查，如果需要则自动扩容。扩容操作最终是通过grow()方法完成的。

5.2.1 追加 (E e)

直接在数组当前最后一个元素后添加。

/**
     * 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);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

modCount：
表明list被结构化修改的次数，存在于 java.util.AbstractList 中，定义方式：protected transient int modCount = 0;， 该字段由迭代器和列表迭代器实现使用，提供 fail-fast 机制。

结构化修改的形式：

  • 指改变列表的大小。
  • 以某种方式干扰列表，使得正在进行的迭代可能产生不正确的结果。

在这里插入图片描述

5.2.2 追加到指定索引位置

此种方式需要对索引位置之后的元素进行移动。

/**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
    	// 校验 index > size || index < 0，防止越界
        rangeCheckForAdd(index);
		
		
        ensureCapacityInternal(size + 1);  // 增加 modCount!!
        // 从指定的源数组复制数组，从指定位置到目标数组的指定位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

在这里插入图片描述

5.3 添加多个元素

在插入之前也需要进行空间检查，如果需要则自动扩容；如果从指定位置插入，也会存在移动元素的情况。 addAll()的时间复杂度不仅跟插入元素的多少有关，也跟插入的位置相关。

addAll(Collection<? extends E> c)

 /**
     * 如果在操作过程中修改了指定集合，则此操作的行为未定义。
     * （这意味着如果指定的集合是该列表，并且该列表是非空的，则该调用的行为是未定义的
     *
     * @param 待加入的集合
     * @return list改变之后返回 true
     * @throws 集合未定义则抛出 NullPointerException
     */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        // 要添加的长度
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // 增加 modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

addAll(int index, Collection<? extends E> c)

	/**
     *
     * @param 插入位置
     * @param 待添加的集合
     * @return list改变之后返回 true
     * @throws index 越界则抛出 IndexOutOfBoundsException
     * @throws 集合未定义则抛出 NullPointerException
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(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;
    }

5.4 赋值/更改 set()

/**
     * 替换指定索引处的值
     *
     * @param index指定要改哪个值
     * @param 元素值
     */
    public E set(int index, E element) {
        rangeCheck(index);

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

5.5 获取指定索引处的值

    public E get(int index) {
    	// 判断 index >= size
        rangeCheck(index);

        return elementData(index);
    }

5.6 删除指定索引处的值

 	/**
     * 删除该值后，元素左移动
     */
    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; // 将最后一个元素设置为null，让GC生效

        return oldValue;
    }

有了垃圾收集器并不意味着一定不会有内存泄漏。对象能否被GC的依据是是否还有引用指向它，上面代码中如果不手动赋null值，除非对应的位置被其他元素覆盖，否则原来的对象就一直不会被回收。

5.7 调整容量为当前数组大小

	/**
     *最小化ArrayList的容量
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

5.8 查找元素

indexOf()

/**
     * 查找元素第一次出现的位置
     * 
     */
    public int indexOf(Object o) {
    	// ArrayList 可以存null值，所以要判断
        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;
    }

lastIndexOf()

/**
     * 查找元素最后一次出现的位置
     */
    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;
    }

6. Fail-Fast机制

ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

参考文档：
https://pdai.tech/md/java/collection/java-collection-ArrayList.html

凡尘技术
关注
专栏目录
ArrayList 源码深度解析
静待花开
02-28 3175
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，存储了6个6的数组，下标（index）从0开始，数组（elementData）表示存储的数据本身。 有哪些基本概念？ index 表示数组下标；...
SpringMVC源码深度解析
weixin_56644618的博客
10-29 3140
springmvc的源码解析，建议收藏，多看几遍！！！
ArrayList源码详解
上善若泪
11-10 417
文章目录1 ArrayList源码1.1 ArrayList定义1.2 底层存储1.3 构造方法1.4 增加1.5 删除1.6 更新1.7 查找1.8 是否包含1.9 容量判断 1 ArrayList源码 工作中经常听到别人讲容器，各种各样的容器，话说到底什么是容器，通俗的讲容器就是用来装东西的器皿，比如：水桶就是用来盛水的，水桶就是一个容器 在我们写程序的时候常常要对大量的对象进行管理，比如查询，遍历，修改等。jdk为我们提供的容器位于java.util包，也是我们平时用的最多的包之一。 但是为什么不用数
java ArrayList源码分析（深度讲解）
Cyan_RA9的博客
03-13 1928
java 集合篇章——ArrayList类源码分析。通过Debug一步一步带你看懂源码!
【JAVA集合篇】ArrayList源码详解
最新发布
初念初恋的博客
06-16 1366
ArrayList是一种以数组实现的List，与数组相比，它具有动态扩展的能力，因此也可称之为动态数组。在ArrayList集合里面可以存储任何类型的数据， 而且它是一个顺序容器，存放的数据顺序就是和我们放入的顺序是一致的，而且它还允许我们放入null元素。
ArrayList源码解析
不管风吹浪打，胜似闲庭信步
02-06 1012
一、光说底层是采用数组的形式，怎么实现的？ 1）成员属性elementData定义 arrayList底层是采用数组的形式，看源码我们可以看到： ArrayList 的元素存储在其中的数组缓冲区。 ArrayList 的容量就是这个数组缓冲区的长度。 添加第一个元素时，任何带有 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空 ArrayList 都将扩展为 DEFAULT_CAPACITY。 transient Object[] elementDa
源码深度解析之 Spring IOC
20年码农
12-14 402
IOC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试。有了 IOC 容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，便于测试和功能复用，整个体系结构更加灵活。
【Java集合框架源码解析】：ArrayList转Array内部原理揭秘，源码级深度解析！
此框架不仅增强了数据处理能力，还提供了线程安全的数据结构，以支持多线程环境下的操作。Java集合框架的核心是各种接口和实现类，其中`Collection`接口是所有单列集合的根接口，而`Map`接口则是处理键值对集合的基
SpringBoot与Mybatis整合源码深度解析
qq_35634181的博客
05-28 2251
问题： SpringBoot中没有Mybatis的配置文件是如何完成对Mybatis的整合？ 在Mapper接口上不加@component或者是@repository也能将Mapper注入到Spring中，是如何实现的？ 所写的Mapper接口是如何关联到xml里面所写的sql语句的？ 如果对于上述三个问题的答案不是很清楚的话，可以往下面，本文将从源码的角度分析SpringBoot与Mybatis整合的源码，对于Spring和Mybatis的整...
通过JSON使Springboot接收List类型参数
j8130的博客
01-17 4099
导入依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.62</version> ...
Java集合源码浅析（一） ： ArrayList
冷血之心的博客
04-12 1702
（尊重劳动成果，转载请注明出处：https://yangwenqiang.blog.csdn.net/article/details/105317442冷血之心的博客） 背景 一直都有这么一个打算，那就是将Java中常见集合的源码进行一个全面的梳理（尽管已经有很多人进行了梳理总结）。重复造轮子的意义就在于，笔者可以亲自去阅读与欣赏JDK集合源码，学习JDK设计者们那优雅的code风格。 那么，就...
java---ArrayList源码解析
m0_58196614的博客
08-23 1524
ArrayList 底层就是一个数组，依赖其扩容机制（后面会提到）它能够实现容量的动态增长，所以 ArrayList 就是数据结构中顺序表的一种具体实现。
ArrayList源码分析（JDK1.8）
starchao
03-19 1836
参考：https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html（合并详细） 参考：https://blog.csdn.net/fighterandknight/article/details/61240861（分开详细） 伪原创 一、简介 ArrayList结构 public class Array...
超详细！ArrayList源码图文解析
cjm2484836553的博客
02-15 2411
不诗意的女程序媛不是好厨师~ 转载请注明出处，From李诗雨—[https://blog.csdn.net/cjm2484836553/article/details/104329665] 《超详细！ArrayList源码图文解析》1.增1.1 add(E object) 直接在尾部添加一个元素1.2 add(int index, E object) 在指定位置添加一个元素补充：扩容规则2.删...
【JDk源码解析之一】ArrayList源码解析
怪盗基德
04-15 5105
1.ArrayList的继承关系如图所示： 2.宏观上说，ArrayList是基于动态数组实现的，数组具有按索引查找的特性，所以访问很快，适合经常查询的数据。 3.具体源码解析。    为什么说ArrayList是动态数组，这个可以看它的构造函数。如下图所示，有两个构造方法，存放元素的elementData是一个数组，同时被初始化。ArrayList的放的元素就是放      在这个
java1.8源码之ArrayList源码解读
技术探求
05-02 1万+
一、ArrayList概述 1.1 ArrayList简介 ArrayList经常用，今天对它的源码探究一二。 一上来顶部有一大串注释，顶部注释参考了这篇博客内容如下： List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的。） ...
java源码分析之ArrayList
热门推荐
jzhf2012的专栏
01-25 3万+
ArrayList就是传说中的动态数组，就是Array的复杂版本，它提供了如下一些好处：动态的增加和减少元素、灵活的设置数组的大小......     认真阅读本文，我相信一定会对你有帮助。比如为什么ArrayList里面提供了一个受保护的removeRange方法？提供了其他没有被调用过的私有方法？     首先看到对ArrayList的定义： public class Arr
《Thinking in Java》深度解析
9. **源码和更新**: 读者可以通过作者的网站获取完整的源码和最新的电子版更新，以便于实践和学习。 《Thinking in Java》因其深入浅出的讲解和实用的示例而受到高度评价，对于希望深化Java知识的程序员来说，它是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值