扩展JDK源码：Java手撕ArrayList【超详细注释】

已于 2023-12-28 10:47:38 修改
阅读量524 收藏 10
点赞数 17
分类专栏： 数据结构算法 文章标签： java 算法 数据结构 系统架构
于 2023-12-28 00:00:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38522648/article/details/135258373
版权

引言

算法和数据结构可以说是程序的核心，不仅是程序高效运行的基础，而且对于解决复杂问题至关重要。ArrayList因其灵活性和高效性在Java编程中占有重要地位。它是一个基于数组实现的动态大小的列表，能够根据需要自动扩展和收缩

在这篇文章中，我们将尝试从头开始实现一个类似于Java标准库（JDK）中ArrayList的数据结构。这个自定义的MyArrayList类将支持泛型，并提供动态数组的核心功能。通过这个过程，我们能更好地理解ArrayList的内部工作原理

目录

  • 概述
  • JDK ArrayList的实现原理
  • JDK ArrayList关键特性
  • JDK ArrayList类图概览
  • 基本实现
  • 创新方法，拓展JDK源码
  • 写在最后

JDK ArrayList 的实现原理

在深入到我们自己的ArrayList实现之前，让我们先快速了解一下Java标准库中ArrayList的工作原理。

Java中的ArrayList是基于数组实现的动态列表。它通过一个内部数组来存储元素，当这个数组的容量不足以容纳更多元素时，ArrayList会创建一个新的更大的数组，并将旧数组中的元素复制到新数组中。这个过程被称为“动态扩容”

JDK ArrayList关键特性：

  • 动态数组：ArrayList使用数组作为其内部数据结构，但与普通数组不同的是，可以动态地扩容
  • 随机访问：由于基于数组，ArrayList支持快速的随机访问，即可以在O(1)时间访问任何位置的元素
  • 自动扩容机制：当添加元素到ArrayList时，如果内部数组已满，ArrayList会自动创建一个更大的数组，并将所有元素复制到新数组中

JDK ArrayList 类图概览：

下面的类图简单展示了ArrayList的结构：
ArrayList uml类图
下文我们将手撕这些方法，并扩展一些jdk没有的方法

基本实现

定义类和构造函数

/**
 * 自定义的ArrayList实现，支持泛型
 * 
 * @param <T> ArrayList中存储的元素类型
 */
public class MyArrayList<T> {
	// 用于存储元素的数组
    private T[] array;  
    // 实际存储的元素数量
    private int size;  

    /**
     * 构造一个初始容量为10的空MyArrayList
     */
    public MyArrayList() {
        // 初始容量设为10
        array = (T[]) new Object[10]; 
        // 初始时，数组中没有元素
        size = 0;                     
    }
}

添加元素

/**
 * 向MyArrayList中添加一个新元素
 * 如果内部数组已满，则会触发自动扩容
 *
 * @param element 要添加的元素
 */
public void add(T element) {
    // 检查是否需要扩容。
    if (size == array.length) {
        resize();
    }
    // 在数组的下一个可用位置添加元素，并递增size
    array[size++] = element;
}

/**
 * 扩容
 * 当数组无法容纳更多元素时，调用此方法将数组容量增加一倍
 */
private void resize() {
    // 创建一个容量是当前数组两倍的新数组
    T[] newArray = (T[]) new Object[array.length * 2];
    // 将旧数组的内容复制到新数组
    System.arraycopy(array, 0, newArray, 0, array.length);
    // 更新内部数组引用到新数组
    array = newArray;
}

添加集合

/**
* 添加一个集合中的所有元素到MyArrayList
*
* @param c 要添加的元素集合
* @return 如果MyArrayList由于调用而改变，则返回true
*/
public boolean addAll(Collection<? extends T> c) {
   boolean modified = false;
   for (T element : c) {
       add(element);
       modified = true;
   }
   return modified;
}

获取元素

/**
 * 获取MyArrayList中指定索引处的元素
 *
 * @param index 要获取元素的索引
 * @return 在指定索引处的元素
 * @throws IndexOutOfBoundsException 如果索引超出数组的当前大小范围
 */
public T get(int index) {
    // 检查索引是否在有效范围内
    if (index >= size || index < 0) {
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }
    // 返回指定索引处的元素
    return array[index];
}

删除元素

/**
 * 从MyArrayList中移除指定索引处的元素
 *
 * @param index 要移除元素的索引
 * @return 被移除的元素
 * @throws IndexOutOfBoundsException 如果索引超出数组的当前大小范围
 */
public T remove(int index) {
    // 使用get方法获取元素同时检查索引有效性
    T element = get(index);

    // 将指定索引之后的元素向前移动一个位置
    for (int i = index; i < size - 1; i++) {
        array[i] = array[i + 1];
    }

    // 释放最后一个元素并减小size
    array[--size] = null;

    // 返回被移除的元素
    return element;
}

contains 方法

/**
 * 检查ArrayList是否包含特定元素
 * @param element 要检查的元素
 * @return 如果找到了元素，返回true，否则返回false
 */
public boolean contains(T element) {
    for (int i = 0; i < size; i++) {
        if ((element == null && array[i] == null) ||
            (element != null && element.equals(array[i]))) {
            return true;
        }
    }
    return false;
}

size 方法

/**
 * 返回MyArrayList中的元素数量
 *
 * @return 当前存储的元素数量
 */
public int size() {
    return size;
}

clear方法

/**
 * 清空MyArrayList，移除所有元素
 */
public void clear() {
    // 遍历数组，将每个元素设置为null
    for (int i = 0; i < size; i++) {
        array[i] = null;
    }
    // 重置元素数量为0
    size = 0;
}

isEmpty 方法

/**
 * 检查MyArrayList是否为空
 *
 * @return 如果列表没有元素则返回true，否则返回false
 */
public boolean isEmpty() {
    return size == 0;
}

isNotEmpty 方法

/**
 * 检查MyArrayList是否不为空
 *
 * @return 如果列表有元素则返回true，否则返回false
 */
public boolean isNotEmpty() {
    return size > 0;
}

indexOf 方法

/**
 * 查找元素在MyArrayList中的索引
 *
 * @param element 要查找的元素
 * @return 如果找到元素，则返回其索引；否则返回-1
 */
public int indexOf(T element) {
    // 遍历数组，寻找匹配的元素
    for (int i = 0; i < size; i++) {
        if (element.equals(array[i])) {
        	// 返回找到的元素的索引
            return i;  
        }
    }
    // 如果没有找到元素，返回-1
    return -1; 
}

lastIndexOf 方法

/**
 * 查找元素在MyArrayList中最后一次出现的索引
 *
 * @param element 要查找的元素
 * @return 如果找到元素，则返回其最后一次出现的索引；否则返回-1
 */
public int lastIndexOf(T element) {
    // 从数组的末尾开始向前遍历
    for (int i = size - 1; i >= 0; i--) {
        // 元素找到时返回当前索引
        if (element.equals(array[i])) {
            return i;
        }
    }
    // 未找到元素
    return -1;
}

removeRange 方法

public void removeRange(int fromIndex, int toIndex) {
    // 检查索引范围的有效性
    if (fromIndex < 0 || toIndex > size || fromIndex > toIndex) {
        throw new IndexOutOfBoundsException();
    }

    // 计算需要移动的元素数量
    int numMoved = size - toIndex;
    // 将toIndex之后的元素向前移动，覆盖掉要移除的部分
    System.arraycopy(array, toIndex, array, fromIndex, numMoved);

    // 计算新的大小
    int newSize = size - (toIndex - fromIndex);
    // 将末尾多余的元素置为null
    for (int i = newSize; i < size; i++) {
        array[i] = null;
    }
    // 更新size
    size = newSize;
}

subList 方法

/**
 * 获取MyArrayList中指定范围内元素的子列表
 *
 * @param fromIndex 子列表的起始索引（包含）
 * @param toIndex 子列表的终止索引（不包含）
 * @return 指定范围内的元素构成的子列表
 * @throws IndexOutOfBoundsException 如果索引范围不合法
 */
public MyArrayList<T> subList(int fromIndex, int toIndex) {
    // 检查索引范围的有效性
    if (fromIndex < 0 || toIndex > size || fromIndex > toIndex) {
        throw new IndexOutOfBoundsException();
    }

    // 创建新的MyArrayList作为子列表
    MyArrayList<T> sub = new MyArrayList<>();
    // 将指定范围内的元素添加到子列表中
    for (int i = fromIndex; i < toIndex; i++) {
        sub.add(array[i]);
    }
    // 返回子列表
    return sub;
}

replace 方法

/**
 * 替换MyArrayList中指定索引处的元素，并返回原来的元素
 *
 * @param index 要替换元素的索引
 * @param element 新元素
 * @return 原来在指定索引处的元素
 * @throws IndexOutOfBoundsException 如果索引超出数组的当前大小范围
 */
public T replace(int index, T element) {
    // 使用get方法获取当前索引处的元素，同时检查索引有效性
    T oldElement = get(index);

    // 将新元素设置到指定索引处
    array[index] = element;

    // 返回被替换的旧元素
    return oldElement;
}

sort默认自然排序

/**
* 根据元素的自然顺序对MyArrayList进行排序
*/
public void sort() {
	// 将MyArrayList转换为数组
	Object[] a = this.toArray();
	// 使用Arrays.sort方法进行排序，没有提供Comparator，将使用元素的自然顺序
	Arrays.sort(a);
	// 更新MyArrayList的内部数组
	System.arraycopy(a, 0, array, 0, size);
}

sort指定比较器排序

/**
* 根据指定比较器对MyArrayList进行排序
*
* @param comp 用于元素比较的Comparator
*/
public void sort(Comparator<? super T> comp) {
   // 将MyArrayList转换为数组
   Object[] a = this.toArray();
   // 使用Arrays.sort方法进行排序
   Arrays.sort(a, (Comparator) comp);
   // 更新MyArrayList的内部数组
   System.arraycopy(a, 0, array, 0, size);
}

创新方法，拓展JDK源码

批量添加元素

public void batchAdd(T... elements) {
    for (T element : elements) {
        add(element);
    }
}

翻转列表

public void reverse() {
    for (int i = 0; i < size / 2; i++) {
        T temp = array[i];
        array[i] = array[size - 1 - i];
        array[size - 1 - i] = temp;
    }
}

随机打乱列表

随机打乱列表中的元素顺序

public void shuffle() {
    Random rnd = new Random();
    for (int i = size; i > 1; i--) {
        swap(i - 1, rnd.nextInt(i));
    }
}

private void swap(int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

查找最大/最小元素

假设元素实现了Comparable接口，可以找到最大或最小的元素

public T findMax() {
    if (isEmpty()) {
        return null;
    }
    T max = array[0];
    for (int i = 1; i < size; i++) {
        if (max.compareTo(array[i]) < 0) {
            max = array[i];
        }
    }
    return max;
}

public T findMin() {
    if (isEmpty()) {
        return null;
    }
    T min = array[0];
    for (int i = 1; i < size; i++) {
        if (min.compareTo(array[i]) > 0) {
            min = array[i];
        }
    }
    return min;
}

去除重复元素

public void removeDuplicates() {
    HashSet<T> set = new HashSet<>();
    int writePointer = 0;
    for (int readPointer = 0; readPointer < size; readPointer++) {
        if (set.add(array[readPointer])) {
            array[writePointer++] = array[readPointer];
        }
    }
    for (int i = writePointer; i < size; i++) {
        array[i] = null;
    }
    size = writePointer;
}

交集

/**
 * 计算当前MyArrayList与另一个MyArrayList的交集
 *
 * @param otherList 要比较的另一个MyArrayList
 * @return 两个列表共有元素组成的新MyArrayList
 */
public MyArrayList<T> intersection(MyArrayList<T> otherList) {
    MyArrayList<T> result = new MyArrayList<>();
    // 遍历当前列表的每个元素
    for (T item : this.array) {
        // 如果另一个列表也包含这个元素，则添加到结果列表中
        if (otherList.contains(item)) {
            result.add(item);
        }
    }
    return result;
}

并集

/**
 * 计算当前MyArrayList与另一个MyArrayList的并集
 *
 * @param otherList 要比较的另一个MyArrayList
 * @return 两个列表所有元素（不包括重复）组成的新MyArrayList
 */
public MyArrayList<T> union(MyArrayList<T> otherList) {
    MyArrayList<T> result = new MyArrayList<>();
    // 将当前列表的元素添加到结果列表中
    for (T item : this.array) {
        result.add(item);
    }
    // 将另一个列表中不重复的元素添加到结果列表中
    for (T item : otherList.array) {
        if (!result.contains(item)) {
            result.add(item);
        }
    }
    return result;
}

差集

/**
 * 计算当前MyArrayList与另一个MyArrayList的差集
 *
 * @param otherList 要比较的另一个MyArrayList
 * @return 存在于当前列表但不在另一个列表中的元素组成的新MyArrayList
 */
public MyArrayList<T> difference(MyArrayList<T> otherList) {
    MyArrayList<T> result = new MyArrayList<>();
    // 遍历当前列表的每个元素
    for (T item : this.array) {
        // 如果另一个列表不包含这个元素，则添加到结果列表中
        if (!otherList.contains(item)) {
            result.add(item);
        }
    }
    return result;
}

MyArrayList类图

MyArrayList uml类图
可以看到我们基本上实现了jdk所有的方法，并且拓展了很多JDK并不支持的方法

写在最后

通过这篇文章，探索了如何从零开始构建一个高效的ArrayList。希望在这个过程中你不仅学到了如何实现这个强大的数据结构，而且也对Java ArrayList操作有了更深刻的理解

编程其实不仅仅是关于写代码，更是关于理解背后的原理，这样我们才能写出更高效、更可靠的代码。希望这篇文章能够激发你们对深入学习Java以及算法数据结构的决心

如果喜欢这篇文章，记得点赞和关注。你的支持是我不断创作和分享的动力！同时，如果你有任何问题或想法，欢迎在评论区留言，让我们一起讨论和成长。

感兴趣的读者也可以看看往期我写的文章：

java实现十大经典排序算法【GIF动画+完整代码+详细注释
Java设计模式实战：从If-Else到策略+工厂方法的演变
Java并发编程深度解析：掌握CompletableFuture的高效异步模式
Lambda表达式深度解析：提升代码效率与可读性
https://blog.csdn.net/weixin_38522648/article/details/135186933
一文搞懂JAVA单例设计模式的所有实现
Redis缓存八大模式，项目应用选型？这篇文章就够了
Redis缓存的八大模式，项目应用如何选型？这篇文章就够了
git的工作原理，实战案例，这篇文章就够了
深入剖析事务ACID实现的底层原理

  • 程序员三毛
程序员三毛
关注
专栏目录
Java 集合框架：ArrayList 的介绍、使用、原理与源码解析
栗筝i的博客
06-17 5733
本文将从介绍 ArrayList 开始，详细探讨其使用方法、工作原理以及背后的源码实现，帮助读者深入理解并灵活运用 ArrayList，以提升编程效率和代码质量。 在接下来的部分中，我们将首先概述 ArrayList 的基本特性及其在 Java 集合框架中的地位。随后，通过实际代码示例展示如何创建、操作和管理 ArrayList。接着，我们会揭示 ArrayList 的内部工作机制，包括其底层数据结构、扩容策略和性能优化等方面的内容。最后，我们将深入分析 ArrayList 的源码，探讨其设计思想和实现细
javajdk源码学习-JavaSourceLearn:JDK源码学习
05-24
jdk源码学习 JavaSourceLearn 版本号 版本 corretto-1.8.0_275 方式 逐步阅读源码添加注释、notes文件夹添加笔记 计划学习任务计划 标题为包名，后面序号为优先级1-4，优先级递减 java.lang Object 1 String 1 ...
手撕ArrayList
qq_42221826的博客
09-08 166
不多BB,直接上代码: public class MyArrayList { //创建数组对象 private Object[] elements; //已使用数组长度 private int size = 0; //初始化数组长度 private final static int INIT_LENGTH = 10; ...
手撕代码之ArrayList
RuiHao-He的博客
08-10 199
public class HrhArrayList { //默认数组大小，支持扩容，一次扩容10 int n = 1; //声明一个数组做底层存储 int[] array = new int[3]; //数组存储元素的个数 int size = 0; public static void main(String[] args) { HrhArrayList arrayList = new HrhArrayList(); arrayList.add(0); arrayList.ad.
【动手实现系列】手撕ArrayList
。。。
12-27 4045
文章目录说到前面实现ArrayList基本操作结构定义初始化集合初始化指定容量大小的集合添加元素将元素添加到集合中的指定位置将元素直接添加到集合尾部移除集合中的所有元素返回集合中首次出现的指定元素的索引查找集合中是否包含指定的元素返回集合中指定位置上的元素判断集合是否为空返回集合中最后一次出现的指定元素的索引移除集合中指定位置上的元素移除集合中首次出现的指定元素（如果存在）用指定的元素替代集合中指...
手撕Java集合源码——list集合
java小豪的博客
06-29 374
Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。Java的java.util包主要提供了以下三种类型的集合： List：一种有序列表的集合，例如，按索引排列的Student的List； Set：一种保证没有重复元素的集合，例如，所有无重复名称的Student的Set； Map：一种通过键值（key-value）查找的映射表集合，例如，根据Student的name查找对应Student的Map。............
【手撕Java集合】为了搞懂 ArrayList，我拼了！！！
aaa_hao的博客
08-20 4868
这是我在学习Java集合框架时对 ArrayList 的源码级解析，我将许多常用的方法都做出了解释，还有许多更为底层的地方没有涉及到，等到以后有机会我再补全。如果这篇文章对您有帮助的话，希望能给作者一个赞哦！！！ 文章目录类图1. ArrayList 的属性2. 构造方法2.1 public ArrayList(int initialCapacity)2.2 public ArrayList()2.3 public ArrayList(Collection<? extends E> c)3. 添
javajdk源码解析-Code-Adventure:Java基础、JDK源码解析、程序人生
05-20
java jdk源码解析 :open_book: ​程序猿探险记 Kong子：“学而不思则罔，思而不学则殆。” :memo: ​目录 Java基础 Java如何将一个Java对象序列化到文件里 ...订阅Java基础、JDK源码解析系列文章。
jdk1.8 源码中文版，jdk直接显示中文注释
06-02
下载后直接去本机jdk目录里替换jdk中的src.zip 再打开idea就能看到中文版的源码注释 示例 https://blog.csdn.net/a7459/article/details/106495622
JDK8源码 注释附带中文翻译
04-27
压缩包中为JDK8的源码，在源码的注释下方附带的中文翻译，是本压缩包的亮点，下方为局部代码，示范给大家： * Sole constructor. Programmers cannot invoke this constructor. * It is for use by code emitted ...
学习JavaEE的日子 Day26 手撕所有集合类底层源码
weixin_69595694的博客
03-12 1112
1.手撕ArrayList底层源码2.手撕LinkedList底层源码ArrayList 和 LinkedList的效率区别手写单向链表手写双向链表3.手撕Vector底层源码扩容机制4.手撕Stack底层源码5.手撕HasSet底层源码 – 了解底层由HashMap实现6.手撕TreeSet底层源码底层由TreeMap实现重点关注构造方法7.手撕TreeMap底层源码理解红黑树添加元素的过程。
【数据结构二】手撕顺序表与ArrayList源码详解
2203_75565612的博客
12-28 971
对于任意一个继承list接口的数据结构我们都应该实现增删改查获取长度清空等方法，以及相应类的构造方法，我们知道Java中为了提高代码的复用，都是通过类继承接口的方式来进行代码试现，下面让我们写这样一个接口。思路： 通过泛型内在放一个顺序表类的方法实现二维列表，然后再利用循环先将每一层的数值填入numRows个顺序表中，再把这numRows个顺序表填入另一个顺序表中，最后这个顺序表就包含了我们想要的结果。注意：我们自己的顺序表没有实现泛型机制，而java提供的ArrayList是实现了泛型的。
ArrayList源码解读笔记
weixin_30394669的博客
03-21 133
简介： 　　ArrayList是我们开发中非常常用的数据存储容器之一，其底层是数组实现的，我们可以在集合中存储任意类型的数据，ArrayList是线程不安全的，非常适合用于对元素进行查找，效率非常高。 线程安全性： 　　对ArrayList的操作一般分为两个步骤，改变位置(size)和操作元素(e)。所以这个过程在多线程的环境下是不能保证具有原子性的，因此ArrayList在多线程的环境下是...
面试手撕ArrayList
PANDA博客
04-06 784
public class MyArrayList { //创建数组对象 private Object[] elements; //已使用数组长度 private int size = 0; //初始化数组长度 private final static int INIT_LENGTH = 10; //数组最大长度 private in...
Java: 手撕Arraylist (扩容)
李佳航的博客
03-11 658
手写简单的ArrayList 要求1: 实现扩容 要求2: 实现增删改查等功能 因为ArrayList底层是数组结构 具有下标 查询更快 直接上代码!!! 代码片段 package com.edit.util.list; import java.util.Arrays; import java.util.StringJoiner; /** * @author...
顺序表
weixin_45309293的博客
10-19 214
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成据的增删查改。 顺序表一般可分为：静态顺序表（使用定长数组存储）；动态顺序表（使用动态开辟的数组存储）。 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更加灵活，根据需要动态分配内存大小。 动态顺序表的实现： public class MyArrayList { public int[] elem; publi
JAVA 手撕底层arrayList代码（arrayList的简单实现）
qq_48508278的博客
07-16 204
一：引言： 这些方法根本不用写，list类当中都有这些方法，可以直接调用，但为了解list类的底层 所以手写了一便 只是实现了简单方法 二：上码： package cn.wyj.two; import javax.management.RuntimeErrorException; public class Demo1_ArrayList手工实现 <E>{ private Object elementdate[]; private int size; private static
Servlet的生命周期
最新发布
wyk的博客
11-13 1337
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
深入理解Java源码：ArrayList与动态规划实现
资源摘要信息:"在本资源中，我们将探讨三个主要的知识点： triangulation（三角测量），如何查看Java源码，以及javaArraylist（Java中的ArrayList类）。 首先，三角测量（triangulation）是一种通过测量从两个不同...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员三毛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值