ArrayList源码解读

最新推荐文章于 2024-07-05 14:56:47 发布
最新推荐文章于 2024-07-05 14:56:47 发布
阅读量581 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52137951/article/details/122098023
版权

文章目录

ArrayList源码解读

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	/**
     *默认数组大小10
     */
    private static final int DEFAULT_CAPACITY = 10;

   /**
     * 指定该ArrayList容量为0时，返回该空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    
    /**
     *当调用无参构造方法，返回的是该数组，刚创建一个ArrayList时，其内数据量为0
     * 它与EMPTY_ELEMENTDATA区别是，该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *真正保存数据的数组，注：这里是Object类型 ===> 构造时传入泛型是必要的
     */
    transient Object[] elementData; 

    /**
     * ArrayList的实际大小，默认为0
     */
    private int size;
    
    /**
    *无参构造函数，使用无惨构造函数时是在第一次添加元素时初始化容量为 10 的。
    *List<String> list = new ArrayList<String>();
    */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    
    /**
    *带初始容量的构造函数
    *List<String> list = new ArrayList<String>(5);
    */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //指定该ArrayList容量为0时，返回该空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 }
方法解析
增加:add(),addAll()
public boolean add(E e) {
    //确保数组大小足够，不够需要扩容（期望容量=size+1）
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //直接赋值，线程不安全的
    //注：这里没有非空判断，因此可以加入null
    elementData[size++] = e;
    // 这里虽然是boolean，但一般只会返回true
    return true;
}

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保容量充足，整个过程只会扩容一次（期望容量=size+a.length)
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 直接将要加入的集合拷贝到elementData后面即可
    // 注：Arrays.copyOf适用于1-->2的拷贝,而sys..适用于对原数组或指定数组的操作
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    // 只有要增加的集合为空时，返回false
    return numNew != 0;
}
扩容
private void ensureCapacityInternal(int minCapacity) {
        //第一步如果原数组为空,那么长度为10,要不然就加一
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
 }
   
 /**
 *判断是否需要扩容，如果新增元素后长度大于原来elementData的长度，需要通过grow(minCapacity)进行扩容
 */
 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
 }
 
 /**
 *grow为扩容核心方法
 *
 */
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //增加到原容量的1.5倍,(oldCapacity >> 1)向前移一位，相当于除2，这里用位运算更快
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 如果扩容后的值 < 我们的期望值，就以期望值进行扩容
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 如果扩容后的值 > jvm 所能分配的数组的最大值，那么就用 Integer 的最大值
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 通过复制进行扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
 }

总结：

  1. 新增时，并没有对值进行严格的校验，所以 ArrayList 是允许 null 值的。
  2. 扩容的规则并不是翻倍，是原来容量大小 + 容量大小的一半，即原来容量的 1.5 倍。
  3. ArrayList 中的数组的最大值是 Integer.MAX_VALUE，超过这个值，JVM 就不会给数组分配内存空间了。 源码在扩容的时候，有数组大小溢出意识，就是说扩容后数组下界不能小于 0，上界不能大于 Integer 的最大值
  4. 扩容完成之后，赋值是非常简单的，直接往数组上添加元素即可：elementData [size++] = e。也正是通过这种简单赋值，没有任何锁控制，所以这里的操作是线程不安全的

扩容是通过这行代码来实现的：Arrays.copyOf(elementData, newCapacity);，这行代码描述的本质是数组之间的拷贝，扩容是会先新建一个符合我们预期容量的新数组，然后把老数组的数据拷贝过去，我们通过 System.arraycopy 方法进行拷贝。

获取元素（索引）
 /**
 *根据索引获取元素
 */
 public E get(int index) {
     rangeCheck(index);
     return elementData(index);
 }
删除：remove()
 /**
 *删除index在中间的元素，后面的元素往前移一位；若是删除最后一位，直接置null
 *
 */
 public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
        //该index之后的长度
        int numMoved = size - index - 1;
        //将index之后的数据往前移一位
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
 }
    
 /**
 *根据元素删除，需要找到元素第一次出现的index，然后将index后面的元素往前移一位
 *
 */
 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;
 }
//执行删除，即数组拷贝
private void fastRemove(int index) {
        // 记录数组的结构要发生变动了
        modCount++;
        // numMoved 表示删除 index 位置的元素后，需要从 index 后移动多少个元素到前面去
        // 减 1 的原因，是因为 size 从 1 开始算起，index 从 0开始算起
        int numMoved = size - index - 1;
        if (numMoved > 0)
        // 从 index +1 位置开始被拷贝，拷贝的起始位置是 index，长度是 numMoved
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
        //数组最后一个位置赋值 null，帮助 GC
        elementData[--size] = null;
}
  • 修改:set()
public E set(int index, E element) {
    //判断索引是否越界   
    rangeCheck(index);
    //获取旧索引的元素，用于返回
    E oldValue = elementData(index);
    //然后将索引对应位置指向新参数
    elementData[index] = element;
    return oldValue;
}
自己实现一个简单的ArrayList
public class myArrayList<E>{
    //ArrayList底层采用数组存放
    private Object[] elementData;
    //默认数组容量
    private static final int DEFAULT_CAPACITY = 10;
    //记录实际ArrayList大小
    private int size;

    public myArrayList(int initialCapacity){
        if(initialCapacity<0){
            throw new IllegalArgumentException("初始容量不能小于10");
        }
        this.elementData=new Object[initialCapacity];
    }
    //默认值为10
    public myArrayList(){
        this(DEFAULT_CAPACITY);
    }

    //获取数组大小
    public int getSize(){
        return size;
    }

    //判断数组是否为空
    public boolean isEmpty(){
        return size==0;
    }

//    //在数组中间插入一个元素
//    public void add(int index,E e){
//        if(index<0||index>size){
//            throw new IllegalArgumentException("添加失败，下标应该大于等于0或者小于数组大小");
//        }
//        if(size==elementData.length){
//            throw new IllegalArgumentException("添加失败，数组满了");
//        }
//
//        for(int i=size-1;i>=index;i--){
//            elementData[i+1]=elementData[i];
//        }
//        elementData[index]=e;
//        size++;
//    }
//    //在数组结尾添加元素
//    public void add(E e){
//        add(size,e);
//    }
//    //在数组首部添加元素
//    public void addFirst(E e){
//        add(0,e);
//    }
    public void add(E e) {
        // 1.判断实际存放的数据容量是否大于elementData容量
        ensureExplicitCapacity(size + 1);
        // 2.使用下标进行赋值
        elementData[size++] = e;
    }

    public void add(int index, Object object) {
        //1.容量检查，如需要扩容则进行扩容。
        ensureExplicitCapacity(size + 1);
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = object;
        size++;
    }

    //minCapacity为扩容时最少需要的容量
    private void ensureExplicitCapacity(int minCapacity) {
        if (size == elementData.length) {
            //获取当前数组的容量
            int oldCapacity = elementData.length;
            //需要扩容的容量。新容量=当前容量+当前容量/2,即将当前容量增加一半
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("添加失败");
        }
        elementData[index] = e;
    }

    //查找元素e的下标
    public int find(E e){
        for(int i=0;i<size;i++){
            if(elementData[i]==e){
                return i;
            }
        }
        return -1;
    }
    // 使用下标获取数组元素
    public E get(int index) {
        if(index<0||index>size){
            throw new IllegalArgumentException("下标错误");
        }
        return (E) elementData[index];
    }
    // 判断是否含有元素
    public boolean contains(E e){
        for(int i=0;i<size;i++){
            if(elementData[i]==e){
                return true;
            }
        }
        return false;
    }
    //删除某下标元素
    public E remove(int index){
        if(index<0||index>size){
            throw new IllegalArgumentException("删除失败，下标错误");
        }
        E o = (E) elementData[index];
        for(int i=index+1;i<size;i++){
            elementData[i-1]=elementData[i];
        }
        size--;
        return o;
    }
    //删除末尾元素
    public E remove(){
        return remove(size-1);
    }


    public static void main(String[] args) {
        myArrayList<Integer> list = new myArrayList<>();

        System.out.println(list.isEmpty());

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(1);

        System.out.println("删除前");
        for(int i=0;i<list.getSize();i++){
            System.out.print(list.get(i)+"  ");
        }
        Integer remove = list.remove(1);
        System.out.println("删除元素为："+remove);

        System.out.println("删除后");
        for(int i=0;i<list.getSize();i++){
            System.out.print(list.get(i)+"  ");
        }
    }
}
总结

面试时关于 ArrayList 要说的事

如果有人问你 ArrayList 知多少，可以从这几个方面出发：

1.ArrayList 的底层是基于数组进行的，进行随机位置的插入和删除、以及扩容时性能很差，但进行随机的读和取时速度却很快。

2.接着可以从源码的角度分析 add、remove、set、get、数组扩容拷贝的过程场景。

3.最后也是特别重要的一点，就是要积极掌握主动性，延伸出 LinkedList 的特点、源码、两者间的对比等。

注：当需要动态数组时我们通常使用 ArrayList 而不是使用类似的 vector，这里有一点说明一下，就是尽管 Vector 的方法都是线程安全的，但其在单线程下需要花费的时间更多，而 ArrayList 尽管不是线程安全的，但其花费的时间很少。

}
``

Panda°
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
ArrayList源码分析
05-05
本篇文章将深入探讨ArrayList的源码，了解其内部实现机制，以及在实际编程中如何有效地使用ArrayList。 1. **ArrayList的构造函数** ArrayList提供了多个构造函数，包括无参构造、指定容量构造和初始化容量并赋值...
Java中的ArrayList的底层源码解读、LinkedList、Vector的区别介绍
04-03
阅读建议：结合代码进行阅读，在阅读的时候进行代码的比对，以及做笔记，结合自己不懂的地方反复观看，源码解读较为枯燥，文档中的步骤给的都很详细，需要大家结合源码一步一步的跟着步骤进行阅读，
arraylist源码解读
dadadajiang的博客
12-10 131
本次源码解析，只暂时解析构造函数，add，remove方法。其余的等有时间再做补充 三种初始化方式 无参数 public ArrayList() { 无参数时将会初始化为一个空的数组 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } ...
Java ArrayList 源码解读
荣兄2016的博客
09-02 283
ArrayList 源码解读 数据结构 底层通过数组实现 可以称为 动态数组 构造函数 // 初始化为空，transient Object[] elementData; public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } public ArrayList(i...
java源码解读-JavaSource:Java源码解读
05-19
在Java编程语言的世界里，源码解读是提升技术深度、理解内部机制的关键步骤。"JavaSource:Java源码解读"项目旨在帮助开发者深入探索Java的内部工作原理，从而更好地运用和优化代码。在这个项目中，我们可以看到一...
java源码解读-java-src:java源码解读
05-19
Java源码解读是Java开发人员深入理解平台工作原理和编程模型的重要途径。在这个"java-src:java源码解读"项目中，我们可以探索Java的核心库，包括JVM（Java虚拟机）、集合框架、并发机制、I/O流、网络编程等多个关键...
ArrayList 深入理解底层
12-21
ArrayList 集合源码解读介绍构造方法add方法remove方法总结 介绍 ArrayList Jdk1.8采用的是数组的数据结构，是非线程安全的一个集合 （多线程下数据不安全），本文章主要讲解ArrayList集合添加和集合扩容，其他方法...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 520
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
Casual_Lei的博客
07-04 643
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 331
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 219
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 909
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 601
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 254
定义返回值类型处理器的组合；测试使用的controller测试方法。
Java中的静态代理与动态代理详解
07-03 392
在Java中，代理模式分为静态代理和动态代理两种形式。缺点是每一个代理类只能为一个接口服务，如果接口增加方法，代理类也需要相应修改。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！静态代理是在编译时就已经确定代理类的实现，代理类与真实类实现相同的接口或继承相同的父类。动态代理是在运行时动态生成代理类，无需手动编写代理类，可以根据需要代理任意接口。通过本文的介绍，相信大家对Java中的静态代理和动态代理有了更深入的理解和应用。
基于springboot的工作绩效管理系统的设计与实现+文档
最新发布
欧阳小白闯天涯
07-05 642
本毕业设计旨在设计与实现基于Spring Boot的工作绩效管理系统，以满足现代企业对绩效管理的需求。随着企业规模的不断扩大和竞争日益激烈，高效的绩效管理成为提升企业竞争力的重要手段。本系统将利用Spring Boot框架搭建，结合MySQL数据库和MyBatis持久层框架，以及Thymeleaf模板引擎，为企业提供全面的绩效管理解决方案。系统功能包括员工和管理员两个角色。员工可通过系统进行绩效管理、工资管理、统计分析、请假管理以及公告管理等操作，从而提升工作效率和满足个人需求。
ThreadLocal作用
m0_73770897的博客
07-02 308
将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。这种变量在线程的生命周期内起作用，减少同一个线程内多个函数。公共变量的传递的复杂度。
Java 汉诺塔问题 详细分析
2301_80641575的博客
07-02 284
汉诺塔问题

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Panda°

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

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

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

打赏作者

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

抵扣说明：

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

余额充值