ArrayList底层源码大总结（扩容机制和初始化）

已于 2024-05-01 21:31:12 修改
阅读量987 收藏 19
点赞数 27
文章标签： java
于 2024-04-29 21:24:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77615930/article/details/138325886
版权

1、 ArrayList容器类

ArrayList 是 List 接口的实现类。是 List 存储特征的具体实现。

特点：查询快，增删慢，主要用于查询遍历数据，为最常用集合之一；

数据结构：数组；

底层分析：数组结构是有序的元素序列，在内存中开辟一段连续的空间，在空间中存放元素，每个空间都有编号，通过编号可以快速找到相应元素，因此查询快；数组初始化时长度是固定的，要想增删元素，必须创建一个新数组，把源数组的元素复制进来，随后源数组销毁，耗时长，因此增删慢。

1.1 构造器

在这里插入图片描述

List<String> list = new ArrayList<>();
List<String> list1 = new ArrayList<>(list);
List<String> list2 = new ArrayList<>(20);

第二种构造器List<String> list1 = new ArrayList<>(list);

源码

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

参数的源码

public interface List<E> extends Collection<E> {
    int size();
    boolean isEmpty();
}

第三种构造器List<String> list1 = new ArrayList<>(20);

System.out.println(list1.size());//0

看到了没，list1还是一个空列表，只不过她的初始容量是20

1.2 添加元素

在这里插入图片描述

List<String> list = new ArrayList<>();
boolean a = list.add("a");
list.add(1,"b");
System.out.println(list);//[a, b]

list.add(3,"b");//IndexOutOfBoundsException

注意：第二种方法，索引不能大于元素的个数。

1.3 获取元素

在这里插入图片描述

在这里插入图片描述

String s1 = list.get(0);
String s2 = list.get(1);
String s3 = list.get(2);
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

1.4 删除元素

在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"d");
System.out.println("列表："+list);

String remove = list.remove(2);
System.out.println("删除的元素"+remove);
System.out.println("列表："+list);
list.remove("d");

输出：

列表：[a, b, c, d]
删除的元素c
列表：[a, b, d]

1.5 替换元素

在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"d");
System.out.println("列表："+list);

String hello = list.set(0, "Hello");
System.out.println("替换的元素"+hello);
System.out.println("列表："+list);

输出：

列表：[a, b, c, d]
替换的元素a
列表：[Hello, b, c, d]

1.6 清空元素

在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"d");
System.out.println("列表："+list);

list.clear();
System.out.println("列表："+list);

输出：

列表：[a, b, c, d]
列表：[]

1.7 判空

在这里插入图片描述

List<String> list2 = new ArrayList<>();
boolean empty = list2.isEmpty();
System.out.println(empty);//true

1.8 判断容器是否包含指定元素

在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"a");
System.out.println("列表："+list);

boolean is = list.contains("a");
System.out.println(is);//true

输出：

列表：[a, b, c, a]
true

1.9 查找元素的位置

在这里插入图片描述
在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"a");
System.out.println("列表："+list);

int index = list.indexOf("a");
System.out.println("a在列表中的第一个位置 "+index);

int lastIndex = list.lastIndexOf("a");
System.out.println("a在列表中的最后一个位置 "+lastIndex);

输出：

列表：[a, b, c, a]
a在列表中的第一个位置 0
a在列表中的最后一个位置 3

1.10 将单例集合转换成数组

转换为 Object 数组

在这里插入图片描述

Object[] array = list.toArray();
for (Object o : array) {
    System.out.print(o + " ");
}

输出：

列表：[a, b, c, a]
a b c a

注意：不可以将转换后的结果强制类型转换（Object可以强转为String，但是你见过将Object数组强转为String数组吗？除非你一个一个的来强转）。想要实现该效果，请看下一知识

String[] arr = (String[]) list.toArray();
for (String s : arr) {
    System.out.print(s+" ");
}

输出：

Exception in thread "main" java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.String; ([Ljava.lang.Object; and [Ljava.lang.String; are in module java.base of loader 'bootstrap')

转换泛型类型数组

在这里插入图片描述

List<String> list = new ArrayList<>();
list.add(0,"a");
list.add(1,"b");
list.add(2,"c");
list.add(3,"a");
System.out.println("列表："+list);

String[] array = list.toArray(new String[list.size()]);
for (String s : array) {
    System.out.print(s+" ");
}

输出：

列表：[a, b, c, a]
a b c a

1.11 容器的并集操作

在这里插入图片描述

List<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println("列表list1："+list1);

List<String> list2 = new ArrayList<>();
list2.add("b");
list2.add("c");
list2.add("d");
System.out.println("列表list2："+list2);

boolean b = list1.addAll(list2);
System.out.println(b);
System.out.println("列表list1："+list1);
System.out.println("列表list2："+list2);

输出：

列表list1：[a, b, c]
列表list2：[b, c, d]
true
列表list1：[a, b, c, b, c, d]
列表list2：[b, c, d]

1.12 容器的交集操作

在这里插入图片描述

List<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println("列表list1："+list1);

List<String> list2 = new ArrayList<>();
list2.add("b");
list2.add("c");
list2.add("d");
System.out.println("列表list2："+list2);

boolean b = list1.retainAll(list2);
System.out.println(b);
System.out.println("列表list1："+list1);
System.out.println("列表list2："+list2);

输出：

列表list1：[a, b, c]
列表list2：[b, c, d]
true
列表list1：[b, c]
列表list2：[b, c, d]

Process finished with exit code 0

1.13 容器的差集操作

在这里插入图片描述

List<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println("列表list1："+list1);

List<String> list2 = new ArrayList<>();
list2.add("b");
list2.add("c");
list2.add("d");
System.out.println("列表list2："+list2);

boolean b = list1.removeAll(list2);//相当于list1-list2
System.out.println(b);
System.out.println("列表list1："+list1);
System.out.println("列表list2："+list2);

输出：

列表list1：[a, b, c]
列表list2：[b, c, d]
true
列表list1：[a]
列表list2：[b, c, d]

Process finished with exit code 0

2、 ArrayList底层的初始化（使用空参构造）

前置知识:ArrayList的重要字段和方法

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

/**
* 用于默认大小的空实例的共享空阵列实例。我们将其与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;

//空参构造器
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

问题的引出

现在有一个代码，问：list1列表是如何初始化的呢？

List<String> list1 = new ArrayList<>();
list1.add("a");

先说结论：

  • JDK1.7时采用立即初始化，也就是说list1列表会在一开始的时候直接elementData = new Object[10]此时elementData的长度为10。

  • JDK1.8之后采用延迟初始化，底层的elementData会被直接初始化为{}（空数组）只有当向列表中添加元素的时候才会将列表的长度改为10（DEFAULT_CAPACITY）

源码分析

追踪代码中的List list1 = new ArrayList<>();

public ArrayList() {//初始化为空数组{}
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

追踪代码中的add方法

add底层：

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

add(e, elementData, size)底层调用了grow方法，grow方法的底层（其实是底层的底层）：

private Object[] grow(int minCapacity) {
    //...
    return elementData = new Object[DEFAULT_CAPACITY];
}

现在你明白了吧，JDK1.8之后的延迟初始化就是在第一次添加元素的时候，进行初始化长度10

现在问你一个问题：此时我们list2.size()的结果是多少呢？答案是1。想一想为什么

3、 ArrayList的扩容机制

目标代码

List<String> list1 = new ArrayList<>();
list1.add("1");
list1.add("2");
list1.add("3");
list1.add("4");
list1.add("5");
list1.add("6");
list1.add("7");
list1.add("8");
list1.add("9");
list1.add("10");
list1.add("11");

追踪list1.add(“1”);

  1. 调用list接口方法
boolean add(E e);
  1. 实际上调用ArrayList类的方法
public boolean add(E e) {
    modCount++;
    add(e, elementData, size);//size 0
    return true;
}
  1. 然后调用ArrayList类的方法
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)//满足条件
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}
  1. 此时，满足条件（s == elementData.length）
private Object[] grow() {
    return grow(size + 1);
}
  1. grow方法底层，又调用了另一个grow方法
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = 
            ArraysSupport.newLength(oldCapacity,
                                    minCapacity -oldCapacity,oldCapacity >> 1);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

  1. 此时，是第一次添加元素，所以不满足if条件，执行else语句

    else语句的本质就是将elementData初始化为DEFAULT_CAPACITY长度

追踪list1.add(“11”);

  1. 调用list接口方法
boolean add(E e);
  1. 实际上调用ArrayList类的方法
public boolean add(E e) {
    modCount++;
    add(e, elementData, size);//size 10
    return true;
}
  1. 然后调用ArrayList类的方法
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)//elementData.length == 10
        elementData = grow();//这是重点
    elementData[s] = e;
    size = s + 1;
}
  1. 此时，满足条件（s == elementData.length）
private Object[] grow() {
    return grow(size + 1);//size == 10
}
  1. grow方法底层，又调用了另一个grow方法
private Object[] grow(int minCapacity) {//minCapacity == 11
    int oldCapacity = elementData.length;//oldCapacity == 10
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = 
            ArraysSupport.newLength(oldCapacity,
                                    minCapacity -oldCapacity,oldCapacity >> 1);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}
  1. 此时，满足if条件，执行ArraysSupport类中的newLength方法
public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
    int prefLength = oldLength + Math.max(minGrowth, prefGrowth); 
    if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
        return prefLength;
    } else {
        return hugeLength(oldLength, minGrowth);
    }
}
  1. 计算得出newCapacity = 15，然后执行 Arrays.copyOf 。最后实现将字符串"11"插入列表，并进行扩容1.5倍的操作

扩容机制总结

当添加一个元素时，检查数组的长度是否足够。如果不够则扩容，够了就不扩容。ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右

注意：ArrayList不存在”当数组剩余容量多少时，我们扩容“

071221098
关注
  • 27
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ArrayList 深入理解底层
12-21
总的来说，深入理解ArrayList的源码对于提升Java编程技能至关重要，特别是对于性能敏感的代码，理解其扩容机制和内部操作可以帮助优化代码，避免不必要的性能开销。同时，对ArrayList的非线程安全性有所认识，有助于...
深入Java集合ArrayList的源码解析
12-21
这篇文章将从ArrayList的基本属性、构造方法、增删改查的操作以及扩容机制等方面进行深入解析。 首先，ArrayList的核心数据结构是一个数组，它的默认容量是10，这个信息在源码的第115行有明确表示。默认容量的定义...
ArrayList的初始化容量与扩容机制解析
qq_52645134的博客
12-18 6244
通过了解初始化容量的作用，以及ArrayList的扩容机制和优化策略，可以更好地应用ArrayList，提高程序的性能和效率。在实际开发中，合理地设置初始容量、避免频繁扩容以及利用批量添加元素等技巧，都能够有效地优化ArrayList的性能表现，提升程序的整体效率。但如果我们事先知道需要存储的元素数量大致范围，就可以通过构造函数初始化指定大小的ArrayList，从而减少动态扩容带来的性能开销。在使用时，若能估算出所需容量的大小，通过初始化容量，可以避免多次扩容以及内存重新分配带来的性能损耗。
ArrayList：初始化和扩容机制的源码分析
lena blog
04-13 282
private static final Object[] EMPTY_ELEMENTDATA = new Object[0]; //1 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0]; //2 transient Object[] elementData; //注意：这里elementData指的是容量的大小，而不是实际存储的大小 public ArrayList(int v...
Java 集合中 ArrayList 的扩容机制原理（面试+读源码）
白白白鲤鱼的博客
05-29 3902
Java 中集合的ArrayList 的扩容机制原理
ArrayList扩容原理，源码追踪（jdk8）
jgdabc的博客
07-27 1114
不会直接取去初始化容量。如果自己初始化容量的话，那么就会调用有参构造方法，按照我们传递的大小去初始化容量，而不是一开始一个空的列表。然后进入到这个方法，这个方法字面意思理解就是确认容量的操作，首先第一句判断肯定是符合的，因为我们调用无参的构造方法的时候就是这句话初始化的。说明一下这个huge,其实一般是不会走到这里的，我使者循环1了添加这么多元素，实在太卡了，所以如果添加这么多元素性能会大大降低。会回到原来的断点的位置一次，然后我们再次进去的时候就来到这里，可以看到这个方法是一直返回true的。
ArrayList的扩容机制
m0_63503151的博客
04-20 552
一文了解ArrayList扩容机制
集合【高级篇】ArrayList、HashMap 、ConcurrentHashMap的底层源码以及相关的扩容机制
NanYII_的博客
12-28 524
文章目录前言一、ArrayList 源码+扩容机制1、ArrayList 简介2、Arraylist 与 LinkedList 区别3、Arraylist核心代码解读4、ArrayList 扩容机制分析二、使用步骤总结 前言   我之前这篇博客 Java高级----List集合、Set集合、Map集合总结 详细介绍了Java中集合相关的基础知识，本篇博客就深入聊聊集合ArrayList、HashMap 、ConcurrentHashMap的底层源码以及相关的扩容机制~ 一、ArrayList 源码+扩容
ArrayList扩容机制和底层分析
weixin_43183850的博客
07-22 3384
ArrayList底层分析
C# 的List 和arrayList的底层扩容机制
Zero_Yuanzhibin的博客
11-26 2030
总体描述：List或者ArrayList 在初始时给出4的默认长度，超出后以2倍的方式扩容；超过0X7FEFFFFF后 会以最大值为长度 但是看.Net源码 如果此时max还小于需求长度 会把长度设为 需求长度； 代码测试： 输出结果： .NET 源码摘取 1.增加元素时判断容量 2.扩容机制 ...
Java集合（三）ArrayList底层源码（扩容机制）
weixin_45385991的博客
03-01 168
Java集合（三）ArrayList底层源码 文章目录Java集合（三）ArrayList底层源码一、ArrayList底层源码1.1、使用无参构造器，创建使用arrayList二、使用步骤1.引入库2.读入数据总结 一、ArrayList底层源码 1.1、使用无参构造器，创建使用arrayList 首先new 一个ArrayList，debugger debugger运行到 new ArrayList（）这个构造方法时，进入这个方法 创建了一个空的elementData数组 = {} 然后再Ctr
ArrayList源码分析
05-05
ArrayList提供了多个构造函数，包括无参构造、指定容量构造和初始化容量并赋值的构造。无参构造函数默认创建一个容量为10的底层数组，而指定容量的构造函数允许我们预设数组大小，避免不必要的扩容操作。 2. **...
Java源码篇之容器类——ArrayList
12-20
在Java编程语言中，ArrayList是...同时，根据实际需求调整初始容量和扩容策略可以减少不必要的内存分配和拷贝，从而提高应用程序性能。在实际开发中，选择合适的集合类以及了解其底层实现是提升代码质量的关键步骤。
java——ArrayList-源码解析.docx
05-09
3. 从 Collection 构造：将给定的 Collection 转换为数组并初始化 ArrayList。 ArrayList 的动态扩容机制是通过 `ensureCapacityInternal` 方法实现的。当添加元素时，如果当前容量不足以容纳新元素，就会触发扩容...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 508
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 276
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1338
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 501
java枚举工具类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值