【集合】- ArrayList源码解析

已于 2022-08-29 20:36:52 修改
阅读量336 收藏
点赞数
分类专栏： # jdk源码解析 文章标签： 源码 后端 arraylist list java
于 2022-08-28 22:14:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiqibei666/article/details/126572556
版权

ArrayList源码解析

简介

概述

ArrayList底层是一个数组，数组元素类型为object，支持动态扩容，所以ArrayList也相当于一个动态数组；ArrayList继承自 AbstractList，实现了 List 接口，允许 null 的存在；

接下来我们通过类层次结构、构造方法及常用方法三方面看ArrayList源码；

类图-继承关系

在这里插入图片描述
ArrayList继承了AbstractList，实现了List、RandomAccess、Serializable、Cloneable这些接口；

  • List：是一个数组队列，提供了相关的添加、删除、修改、遍历等操作；
  • RandomAccess：提供了随机访问功能，ArrayList中可以通过元素序号快速获取元素对象；
  • Serializable：表示ArrayList支持序列化
  • Cloneable：支持克隆

ArrayList的实现

属性

    /**
     * 存储ArrayList元素的数组，
     * 添加到 ArrayList 中的元素数据（第一次添加元素时，空ArrayList会扩容到 DEFAULT_CAPACITY = 10 ）
     */
    transient Object[] elementData;

    /**
     * ArrayList大小，包含元素数量
     */
    private int size;

构造方法

构造方法构造方法描述
ArrayList()构造一个初始容量为10的空列表
ArrayList(int initialCapacity)构造具有指定初始容量的空列表
ArrayList(Collection<? extends E> c)构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序

1. ArrayList()无参构造方法

DEFAULTCAPACITY_EMPTY_ELEMENTDATA，使用无参构造方法创建ArrayList数组的时候，是一种懒加载模式，创建的时候不设置大小，而是在使用的时候设置大小；

//默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
//用于空实例的共享空数组实例，从0开始，按照1.5倍扩容
private static final Object[] EMPTY_ELEMENTDATA = {};

//共享的空数组对象，用户ArrayList() 构造方法，和EMPTY_ELEMENTDATA区分开，在第一次添加元素时，首次扩容为10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

2. ArrayList(int initialCapacity)

根据传入的初始化容量，创建Array数组，如果传入参数是大于等于0，则使用用户的参数初始化，如果传入参数小于0，则抛异常；

public ArrayList(int initialCapacity) {
	//初始化容量>0时，创建Object数组
	if (initialCapacity > 0) {
	     this.elementData = new Object[initialCapacity];
	 //初始化容量=0时，使用EMPTY_ELEMENTDATA对象
	 } else if (initialCapacity == 0) {
	     this.elementData = EMPTY_ELEMENTDATA;
	 //初始化容量<0时，抛IllegalArgumentException异常
	 } else {
	     throw new IllegalArgumentException("Illegal Capacity: "+
	                                        initialCapacity);
	 }
}

3. ArrayList(Collection<? extends E> c)

构造一个包含指定集合元素的列表，这些元素按照 collection 集合迭代器返回的顺序排列的

/**
 * 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
 */
public ArrayList(Collection<? extends E> c) {
	//将C 转换为 object 数组
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
    	//判断集合元素是否为 Object[]类型，不是的话，会创建新的 Object[]数组，并把 elementData 赋值到新数组中，最后赋值给 elementData
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    //如果数组size = 0 ,则直接将空对象 EMPTY_ELEMENTDATA 
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

常用方法

1. add(E e) 方法

顺序添加单个元素到数组

/**
 * 在列表末尾添加元素
 */
public boolean add(E e) {
	//增加数组操作次数
    modCount++;
    //添加元素
    add(e, elementData, size);
    return true;
}
private void add(E e, Object[] elementData, int s) {
    //如果容量不够，进行扩容
    if (s == elementData.length)
        elementData = grow();
    //设置到末尾
    elementData[s] = e;
    //数量大小加一
    size = s + 1;
}

2. add(int index, E element) 方法

插入单个元素到指定位置

public void add(int index, E element) {
    // 校验位置是否在数组范围内
    rangeCheckForAdd(index);
    // 增加数组修改次数
    modCount++;
    //如果数组大小不够，进行扩容
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    //将 index + 1 位置开始的元素，进行往后挪
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);
    //设置到指定位置
    elementData[index] = element;
    //数组大小加一
    size = s + 1;
}
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

3. addAll(Collection<? extends E> c) 方法

批量添加多个元素，如果明确知道会添加多个元素时，使用该方法，避免使用单个元素添加带来的多次扩容；

public boolean addAll(Collection<? extends E> c) {
    //转成 a 数组
    Object[] a = c.toArray();
    //增加操作次数
    modCount++;
    //如果 a 数组大小为 0 ，返回 ArrayList 数组无变化
    int numNew = a.length;
    if (numNew == 0)
        return false;
    //如果 elementData 剩余的空间不够，则进行扩容。要求扩容的大小，至于能够装下 a 数组。
    Object[] elementData;
    final int s;
    if (numNew > (elementData = this.elementData).length - (s = size))
        elementData = grow(s + numNew);
    //将 a 复制到 elementData 从 s 开始位置
    System.arraycopy(a, 0, elementData, s, numNew);
    //数组大小加 numNew
    size = s + numNew;
    return true;
}

4. addAll(int index, Collection<? extends E> c) 方法

从指定位置开始批量添加多个元素

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);
    Object[] a = c.toArray();
    // 增加数组修改次数
    modCount++;
    //如果 a 数组大小为 0 ，返回 ArrayList 数组无变化
    int numNew = a.length;
    if (numNew == 0)
        return false;
    //如果 elementData 剩余的空间不够，则进行扩容，扩容的大小，至于能够装下 a 数组。
    Object[] elementData;
    final int s;
    if (numNew > (elementData = this.elementData).length - (s = size))
        elementData = grow(s + numNew);
    /**
     * 如果 index 开始的位置已经被占用，将原有元素向后移
     */ 
    int numMoved = s - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index,
                         elementData, index + numNew,
                         numMoved);
    //将 a 复制到 elementData 从 s 开始位置
    System.arraycopy(a, 0, elementData, index, numNew);
    //数组大小加 numNew
    size = s + numNew;
    return true;
}

5. remove(int index)方法

删除index位处的数据

public E remove(int index) {
    //校验 index 不要超过 size
    Objects.checkIndex(index, size);
    final Object[] es = elementData;
    //记录该位置的原值
    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    //快速移除
    fastRemove(es, index);
    //返回该位置的原值
    return oldValue;
}

6. fastRemove(Object[] es, int i)快速删除

private void fastRemove(Object[] es, int i) {
    //增加数组修改次数
    modCount++;
    //如果 i 不是最末尾的元素，则将 i + 1 位置的数组往前挪
    final int newSize;
    if ((newSize = size - 1) > i) // -1: size 是从 1 开始，而数组下标是从 0 开始
    	//把i+1位后的 newSize-i的数据往前移一位
        System.arraycopy(es, i + 1, es, i, newSize - i);
    //末尾置为 null
    es[size = newSize] = null;
}

7. indexOf(Object o)查找单个元素

获取指定元素位置，找不到，返回-1

public int indexOf(Object o) {
    return indexOfRange(o, 0, size);
}
int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    //null 的情况
    if (o == null) {
    	//从start循环到end,如果数据为空，则返回对应下标
        for (int i = start; i < end; i++) {
            if (es[i] == null) {
                return i;
            }
        }
    //非 null 的情况
    } else {
        for (int i = start; i < end; i++) {
        	//调用目标函数的equals方法
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

8. lastIndexOf(Object o) 方法

查找元素最后一次出现位置

public int lastIndexOf(Object o) {
	//范围内查询元素最后一次出现位置（即逆第一次出现位置）
    return lastIndexOfRange(o, 0, size);
}
int lastIndexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = end - 1; i >= start; i--) { // 倒序
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = end - 1; i >= start; i--) { // 倒序
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

9. clone() 方法

克隆 ArrayList 对象

// ArrayList.java
public Object clone() {
    try {
        //调用父类，进行克隆
        ArrayList<?> v = (ArrayList<?>) super.clone();
        //拷贝一个新的数组
        v.elementData = Arrays.copyOf(elementData, size);
        //设置数组操作次数为0
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

10. grow()扩容方法

创建一个新的更大的数组，然后将原数组复制到新数组中，最后返回新数组
以下是扩容核心代码：

//JDK 9
private Object[] grow() {
    //调用 #grow(int minCapacity) 方法，要求扩容后至少比原有大1 
    return grow(size + 1);
}
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    //如果原容量大于0 ，或者数组不是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，计算新的数组大小，并扩容
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity,
                oldCapacity >> 1 
        return elementData = Arrays.copyOf(elementData, newCapacity);
    //如果是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 数组，直接创建新的数组
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

//JDK8
private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //将 oldCapacity 右移一位，相当于 oldCapacity / 2
        //将容量更新为 原容量 的 1.5 倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //判断 新容量 与 最小需要容量，如果新容量 < 最小需要容量，就把最小需要容量作为 新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果 新容量 > MAX_ARRAY_SIZE，就 比较 minCapacity 和 MAX_ARRAY_SIZE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        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数组时有无参，无参，则在添加第一个元素的时候，设置 newCapacity = minCapacity(10)，当添加第 11 个元素时，进行扩容，执行 grow() 方法，newCapacity = 15，数组容量扩容至 15，size = 11；
  • 有参时，使用参数容量，添加元素时，判断 容量 够不够，容量满了进行扩容

“>>” 移位运算符：>>1 向右移一位相当于除以2，右移 N 位相当于除以2的 N 次方；
oldCapacity >> 1：oldCapacity 右移了一位，相当于 oldCapacity / 2；

11. set(int index, E element)方法

set(int index, E element)方法，设置指定位置的元素

public E set(int index, E element) {
    // 校验index不要超过 size
    Objects.checkIndex(index, size);
    // 获得index位置的原元素
    E oldValue = elementData(index);
    // 修改index位置为新元素
    elementData[index] = element;
    // 返回index位置的原元素
    return oldValue;
}

12. get(int index) 方法

get(int index) 方法获取指定位置的元素

public E get(int index) {
    Objects.checkIndex(index, size);
    //获得 index 位置的元素
    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

常见问题

总结

  • ArrayList本质是一个数组，动态数组，创建时可以指定初始化容量，当添加元素超过当前容量大小时，会调用grow()进行扩容;
  • 查询元素效率高，插入和删除元素效率不高
@Arielle。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
集合-ArrayList源码分析
java_cG的博客
08-06 197
ArrayList分析继承关系:底层数据结构:特点:源码分析:构造方法:添加方法:删除操作:覆盖操作:获取方法清除操作:包含操作:是否为空: ArrayList是Java集合框架中较为常用的一种数据结构.下面从不同层面来介绍它. 继承关系: ArrayList继承了AbstractList,实现了List,RandomAccess(随机访问),Cloneable,Serializable接口 public class ArrayList<E> extends AbstractList<E&
Java集合之ArrayList源码分析
weixin_42729539的博客
07-23 146
简介 ArrayList是Java中比较常用的一个集合，从单词拼写可以理解它是一个数组的列表，通常具有以下的特性： 元素允许为null 允许重复数据，占用的是数组中不同位置的地址 数据有序，即与添加元素的顺序相同 非线程安全 源码解析 ArrayList为何具有上面的特点以及它适合什么场景中进行使用，下面从源码来分析一下原理(无特别说明时源码皆是jdk1.7)： 基本属性及构造方法 ...
ArrayList详解
ZWP_990527的博客
02-21 380
ArrayList 详解
ArrayList源码剖析
初学、小菜鸡的博客
01-25 610
ArrayList源码剖析 简介 ArrayList 是 java 集合框架中比较常用的数据结构。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 主要成员变量 // 默认初始化容量 private static final int DEFAULT_CAPACITY = 10; //
Java集合 - ArrayList源码解析与性能优化
--土拨鼠--
12-28 999
ArrayList实现了List接口，基于动态数组实现。它允许存储任意类型的元素，并根据需要动态调整容量。在添加、删除元素时，ArrayList会自动进行扩容和缩容操作。
Java 集合框架(2-9)-Collection - ArrayList 源码解析.pdf
07-03
《Java集合框架(2-9)-Collection - ArrayList 源码解析》 ArrayList是Java集合框架中的一个重要组件，它属于List接口的实现类，提供了一种动态数组的逻辑视图。ArrayList以高效、灵活的方式存储和操作对象序列，是...
深入Java集合ArrayList的源码解析
12-21
《深入Java集合ArrayList的源码解析》 ArrayList作为Java集合框架中的重要成员，其底层数据结构和操作方式对于理解Java编程至关重要。这篇文章将从ArrayList的基本属性、构造方法、增删改查的操作以及扩容机制等...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList抽象类。在ArrayList中，我们可以看到它的源码实现了Iterable接口、List接口和Collection接口。下面我们...
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
第二章 ArrayList源码解析1
08-04
第二章 ArrayList源码解析 ArrayList是Java集合框架中的一种动态数组，它继承自AbstractList，并实现了List接口。ArrayList主要用于存储可变大小的对象列表，它的核心是通过一个Object类型的数组elementData来实现...
java后端项目启动失败，解决端口被占用问题
SUMMERENT的博客
07-11 292
报错信息： Web server failed to start . Port 8020 was already in use.netstat -ano | findstr 端口号。taskkill /F /PID 进程ID。举例：关闭8020端口。
后端——全局异常处理
m0_73991249的博客
07-09 398
当我们执行一些错误操作导致程序报错时，程序会捕捉到异常报错，这个异常会存在一个Exception对象里那我们在spring boot工程开发时，当我们执行一个sql查询时报错了，那就会从最底层的Mapper层捕捉到Exception异常，然后一路往Service、Controller传出去那么学过java的应该知道，怎么才能捕捉到这个Exception异常并显示？就得用【try-catch】
如何搭建互联网医院系统源码？医疗陪诊APP开发实战详解
meihusdk的博客
07-11 272
希望本文能够为正在或即将从事相关开发的技术人员提供一些参考和帮助。通过不断的努力和创新，我们可以为患者提供更优质的医疗服务，推动医疗行业的数字化转型。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1088
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
从零手写实现 nginx-25-directive map 条件判断指令
07-10 1111
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat大家好，我是老马。这一节我们将配置的加载，拆分为不同的模块加载处理，便于后续拓展。Nginx 的map指令是一个强大的工具，用于根据变量的值来设置另一个变量的值。它可以用于很多场景，比如基于请求的某些特征来动态设置变量，从而影响后续的处理逻辑。以下是关于map。
Vue2打包部署后动态修改后端接口地址的解决方法
最新发布
G_whang的博客
07-11 476
本篇文章将介绍使用Vue2开发前后端分离项目时，前端打包部署后可动态修改后端接口地址的解决方法。
社区团购小程序源码系统 带完整的安装代码以及搭建部署教程
codeji的博客
07-10 266
在这个数字化时代，线上活动成为了连接用户与组织者的桥梁。为了满足不同场景的需要，开发一个灵活、可定制的在线活动报名表单小程序显得尤为重要。本文将深入介绍一个自定义在线活动报名表单小程序的源码系统，并提供详细的搭建部署教程，确保您能够快速上手并进行二次开发，以适应您的特定需求。源码下载地址：春哥技术博客或帮企商城获取。
vue3中antd上传图片组件及回显
月影神社
07-11 412
先引入：import AntdUploadFile from "@/components/base/UploadNew.vue";1.在项目components/base下新建UploadNew.vue文件（上传图片公共组件）})//点编辑时父组件传入的回显数据。
Vue实战【基于wangEditor富文本编辑器+拖拽实现一个自定义打印模版】
商务合作/软件定制/学习交流
07-11 880
Vue实战【基于wangEditor富文本编辑器+拖拽实现一个自定义打印模版】
arraylist 源码解析
06-10
下面是ArrayList的源码解析： 1. 成员变量 ```java /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值