死磕Java之聊聊ArrayList源码(基于JDK1.8)

死磕JAVA10余年,呕心整理出了核心知识点已经做成PDF,无私奉献 想在面试、工作中脱颖而出?想在最短的时间内快速掌握 Java 的核心基础知识点?想要成为一位优秀的 Java 工程师?本篇文章能助你一臂之力!目前正值招聘求职旺季,很多同学对一些新技术名词都能侃侃而谈,但对一些核心原理理解的不够透彻,特别是对 Java的一些核心基础知识点掌握的不够,例如JVM、常用的算法和数据结构等。正所谓万丈高楼平地起,只有把基础掌握的牢固,才能走的更远,面对不断更新的技术才能快速掌握,同时在面试、工作中也更能脱颖而出! 阅读详情

工作快一年了,近期打算研究一下JDK的源码,也就因此有了死磕java系列

  • ArrayList 是一个数组队列,相当于动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
  • ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
  • ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。
  • ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
  • ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输,包括网络传输与本地文件序列化。
  • 和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中建议选择CopyOnWriteArrayList,当然Vector也可以,但不建议使用。

打个广告,楼主自己造的轮子,感兴趣的请点[github]: https://github.com/haifeiWu/lightconf

ArrayList的UML图

ArrayList的UML图

ArrayList的成员变量及其含义

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

    /**
     * ArrayList默认初始大小为10.
     */
    private static final int DEFAULT_CAPACITY = 10;

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

    /**
     * 当ArrayList不传参数时,elementData默认初始化成DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 实现ArrayList的object数组<br><br/>
     * transient关键字扫盲,在实现Serilizable接口后,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList的大小
     */
    private int size;

    /**
     * 构造一个初始容量的数组
     */
    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);
        }
    }

    /**
     * 初始化一个size为10的空值ArrayList.
     */
    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 {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
}

聊聊ArrayList的主要方法实现


    /**
     * 获取ArrayList对应下标的元素,时间复杂度为O(1).
     */
    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;
    }

    /**
     * ArrayList中追加新值.
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * 在ArrayList的指定下标下添加值,时间复杂度为O(n)
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);

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

    /**
     * 移除指定下标的值,时间复杂度为O(1)。
     */
    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;
    }

    /**
     * 移除指定值,时间复杂度为O(n)。
     */
    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;
    }

    /**
     * Increases the capacity of this <tt>ArrayList</tt> instance, if
     * necessary, to ensure that it can hold at least the number of elements
     * specified by the minimum capacity argument.
     *
     * @param   minCapacity   the desired minimum capacity
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

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

        ensureExplicitCapacity(minCapacity);
    }

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

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

    /**
     * ArrayList的最大长度是2147483639
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 用于ArrayList扩容的方法,扩容的策略是int newCapacity = oldCapacity + (oldCapacity >> 1),即每次扩容是原来长度的1.5倍
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

动手实现ArrayList

由于代码过长,故不在此处一一贴出来,感兴趣的小伙伴可以到我的github查看[github]: https://github.com/haifeiWu/interview-collect/tree/master/src/main/java/com/haifeiwu/interview/structure/list

小结

关于ArrayList的源码,给出几点比较重要的总结:

1、注意其三个不同的构造方法。无参构造方法构造的ArrayList的容量默认为10,带有Collection参数的构造方法,将Collection转化为数组赋给ArrayList的实现数组elementData。

2、注意扩充容量的方法ensureCapacity。ArrayList在每次增加元素(可能是1个,也可能是一组)时,都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时,就设置新的容量为旧的容量的1.5倍,如果设置后的新容量还不够,则直接新容量设置为传入的参数(也就是所需的容量),而后用Arrays.copyof()方法将元素拷贝到新的数组(见下面的第3点)。从中可以看出,当容量不够时,每次增加元素,都要将原来的元素拷贝到一个新的数组中,非常耗时,所以建议在事先能确定元素数量的情况下,使用ArrayList

3、ArrayList的实现中大量地调用了Arrays.copyof()和System.arraycopy()方法。我们有必扒一下这两个方法的代码实现。

 public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

很明显调用了另一个copyof方法,该方法有三个参数,最后一个参数指明要转换的数据的类型,其源码如下:


public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

从代码里面可以看出,copyOf方法实际上是在其内部又创建了一个长度为newlength的数组,然后调用System.arraycopy()方法,将原来数组中的元素复制到了新的数组中。
下面来看System.arraycopy()方法。该方法被标记了native,调用了系统的C/C++代码,在JDK中是看不到的,在这里就不再做更深入的了解,不过按照JDK的一贯做法,使用系统的C/C++代码来复制数组效率上来说肯定是没问题的。

4、ArrayList基于数组实现,可以通过下标索引直接查找到指定位置的元素,因此查找效率高,但每次插入或删除元素,就要大量地移动元素,插入删除元素的效率低。

5、在查找给定元素索引值等的方法中,源码都将该元素的值分为null和不为null两种情况处理,因此看来,ArrayList中是允许元素为null。

爱奇艺Java秋招笔试题核心考点与备考策略 Java技术面试中,集合框架、并发编程和JVM是三大核心考察模块。理解HashMap的数组+链表+红黑树结构及扩容机制,掌握synchronized从偏向锁到重量级锁的升级过程,以及volatile的内存屏障原理,是区分“会用”与“懂原理”的关键。这些底层知识不仅直接对应笔试题中的源码级考点,还广泛应用于高并发系统设计、OOM问题定位和代码优化等工程实践场景。本文以爱奇艺2019秋招Java笔试题(B)为样本,系统梳理这些核心考点的易错点与备考方法,帮助读者校准基础水平,制定高效的复习策略。 阅读详情

相关推荐

【死磕Java集合】-集合源码分析.pdf

PDF文档资源下载

【死磕Java并发】----- 死磕 Java 并发精品合集

【死磕 Java 并发】系列是 LZ 在 2017 年写的第一个死磕系列,一直没有做一个合集,这篇博客则是将整个系列做一个概览。 先来一个总览图: 【高清图,请关注“Java技术驿站”公众号,回复:脑图JUC】 【死磕Java并发】—–深入分析synchronized 的实现原理 synchronized 可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同...

chenssy 的技术博客 1万+

Linux 常用命令大全(2025 最新版)

掌握这些命令,你已能应对80% 的 Linux 日常操作!更多高级技巧(如crontab定时任务、iptables防火墙配置)可参考手册(man 命令名)或官方文档。实践是学习命令的最佳方式,建议在虚拟机或云服务器中多动手操作!

2302_79600390的博客 1921

死磕18个Java8日期处理,工作必用!收藏起来~

伴随lambda表达式streams以及一系列小优化,Java 8 推出了全新的日期时间API。Java处理日期、日历和时间的不足之处:将 java.util.Date 设定为可变类型,以及 SimpleDateFormat 的非线程安全使其应用非常受限。然后就在 java8 上面增加新的特性。瞬时(instant)长短(duration)日期时间时区和周期。同时继承了Joda 库按人类语言和计算机各自解析的时间处理方式。

程序员高级码农的博客 1792

状态错误CS0234命名空间“Windows”中不存在类型或命名空间名“Management”(是否缺少程序集引用?)

解决源码编译UE打包失败问题

五百零一 2339

基于PyQt5的ROS移动机器人的人机交互UI界面

每次做实验的时候,手动rosrun,roslaunch太过麻烦,通过ui界面的话,只需要点点按钮就可以啦 ros_car_py包括运动,建图,导航,ui界面的程序全部打包上传,相互依赖关系见ros_car_py包。 import sys from PyQt5.QtCore import * from PyQt5.QtGui import * from PyQt5.QtWidgets imp...

工大机器人工作室 7366

死磕GC:Java GC 和 GO GC 大对比,看完秒成高高手

从Java高薪岗位和就业岗位来看,云原生、K8S、GO 现在对于 高级工程师/架构师 来说,越来越重要。所以,尼恩给大家写了一个 从Java 快速 转型 Java+ GO 双栖 高手的 PDF 《Go学习圣经 - 技术自由圈 版》。

架构师尼恩 1万+

【FnOS飞牛云 | NAS存储】旧电脑不吃灰,手把手教你搭建完全属于自己的私人网盘

打造属于自己的NAS私人网盘,亲测有效,值得一试

木子Linux的博客世界 9425

死磕 java线程系列之线程池深入解析——普通任务执行流程

(手机横屏看源码更方便) 注:java源码分析部分如无特殊说明均基于 java8 版本。 注:线程池源码部分如无特殊说明均指ThreadPoolExecutor类。 简介 前面我们一起学习了Java中线程池的体系结构、构造方法和生命周期,本章我们一起来学习线程池中普通任务到底是怎么执行的。 建议学习本章前先去看看彤哥之前写的《死磕 java线程系列之自己动手写一个线程池》那两章,有助于理解本章...

彤哥读源码 615

STM32(HAL库)软件IIC驱动OLED

本文通过STM32F103C8T6单片机(HAL库)通过软件IIC方式对OLED进行驱动。

weixin_44597885的博客 9767

无刷电机FOC硬件电路设计

本文先对MIT无刷电机FOC硬件电路分析做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章软件程序在我另外一个博客【嵌入式–伺服电机】MIT无刷电机FOC驱动程序分析。

qq_35635374的博客 575

死磕Java之聊聊LinkedList源码(基于JDK1.8)

工作快一年了,近期打算研究一下JDK的源码,也就因此有了死磕java系列 LinkedList 是一个继承于AbstractSequentialList的双向链表,链表不需要capacity的设定,它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口,能对它进行队列操作,提供了相关的添加、删除、修改、遍历等功能。 ...

XYC3939的博客 174

AI上推荐 之 多任务loss优化(自适应权重篇)

1. 写在前面 在多任务学习中,往往会将多个相关的任务放在一起来学习。例如在推荐系统中,排序模型同时预估候选的点击率和浏览时间。相对于单任务学习,多任务学习有以下优势: 多个任务共享一个模型,占用内存量减少; 多个任务一次前向计算得出结果,推理速度增加; 关联任务通过共享信息,相互补充,可以提升彼此的表现。 前面的一篇文章,主要是从模型结构的角度聊了下多任务学习,介绍了工业界非常经典也常用的MMOE模型,然而,对于多任务学习, Loss的优化也非常重要, 因为我们知道通过多个目标去指导网络进行统一的训练

Miracle8070 1万+

Java校招笔试题深度复盘:从基础语法到JVM核心考点

在Java技术生态中,笔试环节始终是校招筛选候选人的重要关卡。它考察的不仅仅是语法记忆,而是对面向对象、集合框架、JVM内存、多线程等核心概念的底层理解与工程实践能力。理解这些基础原理,不仅有助于通过面试中的高频考题,更能帮助开发者在真实项目中快速定位问题,比如内存泄漏、并发安全或异常处理不当等隐患。对于即将进入职场的技术新人而言,扎实掌握这些知识,是构建完整技术体系的基石。本文以一份经典校招Java笔试试卷为例,梳理其中反复出现的核心考点,从基础语法到JVM内存模型,从排序算法到Lambda表达式,逐一剖

weixin_34183910的博客 920

Open3D 点云变换【2025最新版】

点云平移、旋转、缩放、欧式变换的python代码实现。博客长期更新,本文最近更新时间为:2025年1月16日。

点云侠的博客 37万+

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

科陆集团Java工程师笔试真题解析:基础语法到算法实战

Java后端面试常从语言基础、集合原理、JVM运行机制与算法基本功等通用概念入手。理解面向对象设计、接口与抽象类的边界,掌握HashMap的哈希寻址与扩容机制,是构建扎实技术底座的关键;而OOM异常的类型与排查思路,则直接体现解决线上问题的素养。在实际工程中,枚举类型用于状态建模、lambda函数简化集合操作,能有效提升代码可读性与安全性;冒泡排序与快速排序的手写实现,则考验对边界条件的细致把握。对于初学者,java环境变量配置、vscode运行java报错乱码、源发行版提示等问题常成为入门障碍,规范工具链

weixin_33755557的博客 399

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

2024百度Java秋招笔试复盘:考点、算法与避坑清单

Java基础与JVM内存管理是后端开发笔试面试中的高频考点,无论是HashMap的红黑树转换条件、OOM异常的实际触发场景,还是线程池饱和策略的执行顺序,这些概念都直接关系到候选人对工程原理的理解深度。从标识符命名规则、运算符与表达式等语言基础细节,到快速选择算法与输入输出优化等实战技巧,系统性掌握这些知识能显著提升笔试通过率。本文以2024年百度Java工程师秋招第一批笔试为样本,结合题型分布、核心考点复盘、常见编译环境问题与边界条件排查方法,为准备大厂Java岗秋招的候选人提供了一份可操作的备考地图。

weixin_33889665的博客 428

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Java校招笔试核心考点与实战避坑指南

在软件工程人才筛选中,校招笔试既考核语言基础又检验工程素养。理解JVM内存模型与运行时数据区,是定位 java: outofmemoryerror: insufficient memory 等线上故障的根基;掌握lambda函数与java stream的声明式编程,则是现代Java开发的必备技能。从集合原理到并发编程,从SQL优化到Linux排查,笔试题目往往围绕高频基础知识展开。本文以网易Java开发工程师笔试题型为例,梳理考点框架、备考方法与考场时间策略,帮助求职者扎实基本功、规避常见陷阱,稳步通关校招

weixin_34414196的博客 276

用友2023秋招Java笔试完整复盘:考点解析与避坑指南

Java基础、集合框架与并发编程是校招笔试的核心考察方向,而企业级开发中Spring事务、Redis缓存和JVM调优更是高频考点。理解HashMap的扩容机制、JDK 8前后锁粒度变化、线程池参数计算等原理,能帮助候选人在客观题中快速得分。结合Top K问题、矩阵动态规划等常见算法题型,掌握堆排序与状态压缩的工程实践技巧,则能提升编程题的通过率。在真实场景中,在线笔试环境常受JDK版本、编码格式和Lombok插件限制,提前熟悉牛客网系统并合理分配时间至关重要。本文基于一场真实的用友集团秋招Java岗笔试经历

weixin_34054866的博客 353

爱奇艺Java笔试复盘:从基础语法到并发与算法的考点全解析

Java作为企业级应用开发的主流语言,其语法基础、集合框架、JVM内存管理和并发编程能力,是衡量开发者技术水平的核心指标。在技术面试与笔试中,HashMap底层原理、线程池参数配置、快速排序实现等知识点反复出现,背后是对工程实践能力的深层考察。理解标识符规则、运算符隐式转换、枚举类型的使用以及Comparator自定义排序逻辑,能帮助开发者规避常见编码陷阱。掌握OutOfMemoryError的排查路径和JVM参数调优,是应对高并发场景下系统稳定性的关键能力。从基础语法到算法实现,系统梳理这些高频考点,本文

weixin_34228387的博客 352

贝壳2024秋招Java笔试深度解析:基础、集合、JVM与算法全攻略

Java开发者求职秋招,笔试环节往往决定能否进入面试。面对大厂笔试题,扎实的java基础与常见框架实战经验缺一不可。从java面试八股文中的运算符、枚举、异常,到集合与Lambda、JVM内存模型,再到算法与工程化场景,知识点覆盖面广且容易失分。以贝壳2024届秋招Java工程师笔试为例,梳理高频考点、易错陷阱和高效答题策略,帮助读者快速定位薄弱环节,提升笔试通过率。

weixin_34174322的博客 300

Java校招笔试通关指南:从集合框架到并发JVM的核心考点

在Java后端开发岗位的校招笔试中,除了扎实的语言基础,更看重对底层原理与工程实践的深度理解。集合框架作为高频考点,要求掌握HashMap扩容机制、红黑树转换条件以及ArrayList的subList陷阱等源码级细节;而并发编程则聚焦Synchronized锁升级、线程池任务调度策略及AQS原理,这些知识点直接决定了多线程场景下的代码可靠性。JVM内存模型与GC回收机制同样是笔试分水岭,理解GC Roots判定、G1收集器特性与类加载过程,能帮助候选人快速定位生产环境中的性能瓶颈。算法部分则需熟练运用滑动窗

weixin_34198453的博客 396

GitHub 60K星Java面试项目深度拆解:从背题到建体系

在Java技术栈的学习与面试准备中,很多开发者面对海量面试题常常陷入死记硬背的困境,究其根源是缺乏系统化的知识组织方式。一个优秀的知识体系应当从底层原理出发,串联起JVM内存模型、并发编程、MySQL索引与事务、Redis缓存一致性等核心模块,帮助学习者构建可迁移的解题思维。通过理解源码设计、整理知识树、结合实战场景复盘,能显著提升技术深度与面试表现。本文以GitHub上一个标星60K的Java面试项目为蓝本,拆解其内容组织逻辑与高效使用方法,探讨如何将零散的知识点转化为可灵活调用的工程能力,从而在面试与真

weixin_30326741的博客 300
上一篇: 复杂业务下向Mysql导入30万条数据代码优化的踩坑记录
下一篇: 死磕Java之聊聊LinkedList源码(基于JDK1.8)
whfstudio
博客等级 码龄10年 12粉丝 46原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值