我要剖析你之ArrayList源码分析

最新推荐文章于 2024-08-22 16:13:15 发布
最新推荐文章于 2024-08-22 16:13:15 发布
阅读量642 收藏
点赞数
分类专栏： 源码分析 文章标签： 源码 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gmowcey/article/details/66972247
版权

预备知识

1、了解方法System.arraycopy(src, srcPos, dest, destPos, length)。这是一个本地方法，方法的主要作用是将src数组中从srcPos位置开始的元素复制到目标数组dest中，并从dest的destPost位置开始填充。length为需要复制src的中元素的个数。
2、位运算“>>”的作用：xx>>1相当于xx/2
3、另外需要说明的是次分析是基于jdk1.7.0_79

ArrayList

继承关系

*需要说明的是这里只分析ArrayList，所以AbstractList的继承体系并没有详细画出

实现原理

在ArrayList的实现原理其实很简单：在内部使用一个Object数组存放数据，当需要储存数据的数据量大于这个数组的长度时，则重新创建一个数组，将原数组的数据复制到这个新数组中，这样就实现了自动扩容。

源码分析

为了在分析的时候，减少代码注释和方法跳转说明，先来看几个比较重要的成员变量和私有方法，熟悉完成下面的属性和私有方法，ArrayList的核心源码就差不多已经了解了。

成员属性

//定义在ArstractList中，每增加删除一个元素都会+1
protected transient int modCount = 0;
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//长度为0的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于存放元素的数组
private transient Object[] elementData;
//记录元素个数
private int size;
//最大允许保存元素数量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

私有方法 

   //核心方法：从方法名可以看这，这个是保证elementData是否有足够容量来存放元素的方法
   private void ensureCapacityInternal(int minCapacity) {
        //如果elementData还是0长度数组
        if (elementData == EMPTY_ELEMENTDATA) {
            //DEFAULT_CAPACITY默认为10的
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    //核心方法：这里开始计算，判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // 如果minCapacity>elementData.length,需要扩容了
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //核心方法：自动扩容的实现
    private void grow(int minCapacity) {
        //保存旧容量
        int oldCapacity = elementData.length;
        //计算出新容量，即在旧容量的基础上扩容50%
        int newCapacity = oldCapacity + (oldCapacity >> 1);

        //这里是对newCapacity 进行修正，避免newCapacity>MAX_ARRAY_SIZE或<旧容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 这里是将elementData复制到一个新数组中，新数组的长度为之前计算出来的newCapacity
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //这里检查index有超出元素的个数
    private void rangeCheck(int index) {
        //size记录了elementData中保存的元素数量，并不一定等于elementData.length。
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    //与rangeCheck相似，只是增加了判断index<0
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

现在从构造方法开始，逐步分析在日常生活中常用的方法。

public ArrayList() {
    super();
    //默认的构造函数是不会创建新的Object数组的
    this.elementData = EMPTY_ELEMENTDATA;
}

public ArrayList(int initialCapacity) {
     super();
     if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    //创建一个Object数组
    this.elementData = new Object[initialCapacity];
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
         //这个方法底层也是调用的System.arraycopy(src,  srcPos, dest, destPos, length)这个方法
         elementData = Arrays.copyOf(elementData, size, Object[].class);
}

//添加一个元素，核心在ensureCapacityInternal方法中
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

//添加元素到指定位置，核心点在如何空出index这个位置
public void add(int index, E element) {
    rangeCheckForAdd(index);//边界检查
    //自动扩容判断，保证elementData有足够的容量来存放元素
    ensureCapacityInternal(size + 1);  
    //这里实现了将elementData中的元素，将index及其之后的元素全部向后移一位，这样就将index位置空出
    System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
    //将e插入到index位置
    elementData[index] = element;
    size++;
}

//添加一个集合
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    //保证element有足够的空间
    ensureCapacityInternal(size + numNew);
    //复制数据到elementData中
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}
//将一个集合添加到指定的位置，其实现方式与add(index, e)类似，都是通过先挪出足够的空间，再将数据复制到其中
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    //保证element有足够的空间
    ensureCapacityInternal(size + numNew);

    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;
}
//删除指定位置的元素
public E remove(int index) {
    //范围检查，超过范围会抛出一异常
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    //重新整理elementData，即将index后面的元素全部往前移一个位置，与add刚好相反
    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;
}

//删除指定元素
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;
}

//删除指定元素的最终实现，其实与remove实现几乎一样，少了一个范围检查而已
private void fastRemove(int index) {
    modCount++;
    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
}

//删除指定范围内的元素，实现方式就是拿toIndex之后的元素，覆盖掉fromIndex之后的元素
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    //将toIndex之后的元素前移toIndex-fromIndex位
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
             numMoved);

    // 计算出新的元素个数，将清除超过newSize的元素，因为它们是已经删除的
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }

    //更新size值
    size = newSize;
}

//查找元素，没有什么可分析的，逐个比较元素而已。
public int indexOf(Object o) {
    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;
}

//清楚所有元素
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

现在常用方法已经分析完成，最后在看看Itertaor是怎么实现的

private class Itr implements Iterator<E> {
    int cursor;       //当前访问元素的坐标
    int lastRet = -1; //上一次返回元素的坐标
    int expectedModCount = modCount;//亮点来了：将ArrayList被修改的次数保存下来，想要知道有什么用，继续看~_~

    //为了看两点，我把这段代码位置提前了
    final void checkForComodification() {
        //快看、快看，亮点出来了：这里判断了“当前的modCount”与“创建Iterator对象时的modCount”是否一样，如果不一样，则会抛出ConcurrentModificationException异常。看到这里各位看官是否想到ArrayList不支持多线程修改的问题了~_~。其实抛出ConcurrentModificationException不仅仅可以发生在多个线程同时修改的时候，及时在单线程也可能发生，具体怎么发生各位肯定已经想到了。
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

    //只要当前范围元素的坐标不等于size，那么就还有元素
    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        //检查ArrayList有没有被修改过
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();

        Object[] elementData = ArrayList.this.elementData;
        //重复检查ArrayList有没有被修改过
        if (i >= elementData.length)
            throw new ConcurrentModificationException();

        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();

        //检查ArrayList有没有被修改过
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            //内部重新获取最新的modCount值
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

另外ArrayList内部还有一个SubList，不过了解上面实现之后，SubList也简单了，想要了解各位可以自己看看，这里就不在描述。

总结

其实ArrayList的实现相对比较简单，内部也就一个Object[]存放数据。不像HashMap那么相对复杂。只需要理解了它的自动扩容机制，ArrayList的源码就简单了。

ArrayList源码分析
05-05
本篇文章将深入探讨ArrayList的源码，了解其内部实现机制，以及在实际编程中如何有效地使用ArrayList。 1. **ArrayList的构造函数** ArrayList提供了多个构造函数，包括无参构造、指定容量构造和初始化容量并赋值...
Java编程中ArrayList源码分析
08-28
Java编程中ArrayList源码分析 Java编程中ArrayList源码分析是Java编程中一个重要的知识点，对于Java开发者来说，了解ArrayList的源码可以帮助他们更好地理解Java集合框架的实现机制，从而提高自己的编程水平。 ...
java ArrayList源码分析（深度讲解）
Cyan_RA9的博客
03-13 2095
java 集合篇章——ArrayList类源码分析。通过Debug一步一步带你看懂源码!
【Java】ArrayList源码分析
qq_39921135的博客
07-02 904
假设集合第一次新建的长度为10的数组已经装满了，然后此时我需要一次性添加100个数据，很显然，长度为10的数组扩容1.5倍为15个数据的数组，肯定不够，此时新数组的长度就以实际情况为准：110（原来的10个 + 新增加的100个数据）。当原来10个元素的数组存满时，它会创建一个新的数组，新数组长度是原来的1.5倍，也就是长度为15。当我们不断的添加，数组里面的元素存满了，这个时候如果需要继续再存，在底层就需要自动扩容。这个类的源码比较多，看起来不太方便，因此我们需要将它的大纲视图罗列出来，有两种办法。
Java 集合—— ArrayList 源码分析
weixin_44814196的博客
08-22 879
分析 ArrayList 的底层数据结构和扩容机制。
Java之ArrayList源码简单分析
qq_43164662的博客
11-10 511
ArrayList 源码简单分析，更深刻的理解ArrayList的基础结构、初始化、添加元素以及如何做到扩容的newCapablity()函数。
【源码】ArrayList 源码分析
来到人间不过是个蹭饭的客人，还挑什么酸甜苦辣。
06-22 480
本文主要介绍了ArrayList的相关知识，底层数据结构，数组集合相互转换，源码主要分析了其扩容机制。
深入理解 ArrayList 及底层源码分析
好好学java
05-03 1066
1、什么是 ArrayList可以简单的认为是一个动态数组；实际上 ArrayList 就是用数组实现的，长度不够时，调用 Arrays.copyOf 方法，拷贝当前数组到一个新的长度更大的数组；ArrayList 是可调整大小的数组，实现了 List 接口。实现所有可选列表操作，并允许所有元素包括 null。除了实现 List 接口之外，该类还提供了一些方法来操纵内部使用的存储列表的数组的大小。（这个类是大致相当于 Vector，不同之处在于它是不同步的）。
ArrayList 源码分析
搬运Gong
03-23 1005
ArrayList的初始化过程及动态扩容机制源码分析
Java源码分析之ArrayList
博采众长，自成一派；
10-12 397
Java数据结构内部实现原理分析之ArrayList 文章目录Java数据结构内部实现原理分析之ArrayList前言ArrayList简介ArrayList是什么常见方法的时间复杂度概述动态增长概述非同步性遍历器ArrayList详解如何存储元素默认容量最大容量存储数组构造函数容量函数trimToSizeensureCapacitygrownewCapacityhugeCapacity索引函数操...
Java集合系列之ArrayList源码分析
08-27
本文将深入ArrayList的源码，探讨其内部实现、构造方法以及增删改查操作。 1. **内部结构与构造方法** ArrayList的核心成员变量是一个Object类型的数组`elementData`，用于存储元素。数组的初始容量默认为10，可以...
航空公司客户满意度数据转换与预测分析Power BI案例研究
11-16
内容概要：本文档介绍了航空公司的业务分析案例研究，涵盖两个主要部分：a) 使用SSIS进行数据转换，b) 利用RapidMiner进行预测分析。这两个任务旨在通过改善客户满意度来优化业务运营。数据来源包括多个CSV文件，如flight_1.csv、flight_2.csv、type.csv、customer.csv 和 address.csv。第一部分要求学生创建事实表、客户维度表和时间维度表，并描述整个数据转换流程。第二部分则需要利用RapidMiner开发两种不同的模型（如决策树和逻辑回归）来预测客户满意度，并完成详细的报告，其中包括执行摘要、预测分析过程、重要变量解释、分类结果、改进建议和伦理问题讨论。 适合人群：适用于对数据科学和商业分析有一定基础的学生或专业人士。 使用场景及目标：本案例研究用于教学和评估，帮助学员掌握数据转换和预测建模的技术方法，提高客户满意度和业务绩效。目标是通过实际操作加深对相关工具和技术的理解，并能够将其应用于实际业务中。 其他说明：此作业占总评的40%，截止时间为2024年10月25日16:00。
课题设计-基于MATLAB平台的图像去雾处理+项目源码+文档说明+课题介绍+GUI界面
11-16
一、课题介绍 现在我国尤其是北方城市，工业发达，废弃排放严重，这使得雾霾越来越厉害，让能见度极低。这严重影响了我们的交通系统，导航系统，卫星定位系统等，给人民出行，工作带来极大的不便利。目前市场上高清拍摄设备虽然可以让成像清晰点，但是造价高昂。如果有一套软件处理系统，可以实时地处理含雾的图像，让成像去雾化，让图像变得清晰，将会很受欢迎。 该课题是基于MATLAB平台的图像去雾处理，配备一个人机交互GUI界面，可以选择全局直方图均衡化，Retinex算法，同态滤波，通过对比处理前后的图像的直方图，而直方图是一副图像各灰度值在0-256的分布个数的表，信息论已经整明，具有均匀分布直方图的图像，其信息量是最大的。 二、算法介绍 ①全局直方图均衡化：通俗地理解就是，不管三七二十一，直接强行对彩色图像的R,G,B三通道颜色进行histeq均衡处理，然后进行三通道重组； ②Retinex算法：通俗地讲就是，分离R,G,B三通道，对每个通道进行卷积滤波。
微信支付V2版本的支付接口，java的SDK
11-16
微信支付V2版本的支付接口，java的SDK
ide-eval-resetter-2.1.14 无限试用插件
最新发布
11-16
一款IDEA好用的插件，适用于旗舰版，可以延长试用期限，你懂的！
电力系统继电保护整定及其应用-发电机组与变压器保护
11-16
内容概要：本文详细介绍了发电机组保护整定方法，讨论了发电机可能遇到的故障状态及相应的保护措施，包括定子绕组故障、转子绕组故障、过电流、过电压等情况，并提供了具体的保护配置。接着，对变压器常见故障进行了分类说明，并给出变压器的主保护和后备保护配置方案。文章进一步计算了不同短路点的短路电流，阐述了互感器的选择标准，并举例解释了纵联保护的应用和后备保护的作用。 适合人群：电力系统工程师、继电保护技术人员及相关研究领域的学者。 使用场景及目标：适用于发电厂和变电站的设计、维护和运行人员，旨在提高电力系统的安全性和稳定性。目标是确保电力系统关键设备的安全运行，防止故障的发生，减少事故造成的损失。 其他说明：本文不仅提供了详细的理论分析，还包括了大量的数据计算和实例说明，有助于读者更好地理解和掌握继电保护的相关知识和技术。
基于C++开发的微商系统项目源码.zip
11-16
基于C++开发的微商系统项目源码 使用技术：C++/Qt、Mysql、TCP/IP 软件架构 三个大端：服务端、客户端（买家端）、业务端（卖家端） PS:需要连Mysql数据库才能正常使用，连接mysql时记得把用户、密码啥的改为自己的数据库信息
1503ANDH1503002016_20241116222825
11-16
1503ANDH1503002016_20241116222825
深度解析Java ArrayList源码
以下是对ArrayList源码中关键部分的分析： 1. **数据结构**： ArrayList底层使用一个Object类型的数组`elementData`来存储元素。当数组满时，会通过扩容机制自动创建一个新的更大的数组并将原有元素复制过去。 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值