容器 - ArrayList源码解析

已于 2024-04-11 20:53:51 修改
阅读量292 收藏
点赞数 7
分类专栏： 容器 文章标签： java 容器 后端
于 2024-04-11 19:42:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43191747/article/details/137650050
版权

构造方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    	private static final long serialVersionUID = 8683452581122892189L;

    	private static final int DEFAULT_CAPACITY = 10;         	//默认初始容量大小	
   		private static final Object[] EMPTY_ELEMENTDATA = {};   // 空数组（用于空实例）当用户指定 ArrayList 容量为0 时，返回该空数组。	

	    // 当用户没有指定 ArrayList 的容量时(即调用无参构造函数)，返回的是该数组
	    // 刚创建一个 ArrayList 时，其内数据量为0，用户第一次添加元素时，该数组扩容，变成默认容量为10(DEFAULT_CAPACITY) 的一个数组
    	private static final Object [] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     	// 保存ArrayList数据的数组，避免java自带的序列化机制，可用writeObject和readObject读写
    	transient Object [] elementData; 
 		private int size;    
		protected transient int modCount = 0;   // 用来实现fail-fast机制的

	    // 带初始容量参数的构造函数。（用户自己指定容量）
	 	public ArrayList(int initialCapacity) {
	        	if (initialCapacity > 0) {
	            	    //创建initialCapacity大小的数组
	            		this.elementData = new Object[initialCapacity];
	       		 } else if (initialCapacity == 0) {
	            		//创建空数组
	            		this.elementData = EMPTY_ELEMENTDATA;
	       		 } else {
	            		throw new IllegalArgumentException("Illegal Capacity: "+   initialCapacity);
	        	}
	   	 }

	  	// 无参构造函数：创建一个空的 ArrayList，长度为 0，当元素第一次被加入时，扩容至默认容量 10
	    public ArrayList() {
	         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	    }
	
	     // 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
	    public ArrayList(Collection<? extends E> c){
	        	elementData = c.toArray();
	       		 if ((size = elementData.length) != 0) {
	           		 	// c.toArray 可能返回的不是Object []，所以加于判断，用到了反射里面的getClass()方法
	            		if (elementData.getClass() != Object[].class)
	                		elementData = Arrays.copyOf(elementData, size, Object[].class);
	       		} else {
	           		this.elementData = EMPTY_ELEMENTDATA;
	        	}
	    	}

	     // 将数组缓冲区大小调整到实际 ArrayList 存储元素的大小;     
	    public void trimToSize() {
			 	// 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的,该字段表示list结构上被修改的次数。
			   modCount++;     
			   // 如调用默认构造函数后，刚添加一个元素，此时 elementData.length = 10，而 size = 1，使得空间得到有效利用，减少资源浪费.
	           if (size < elementData.length) {
	                 elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
	           }
	    }

		....
}

ArrayList的扩容机制

 //得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
    // 当 要 add 进第1个元素时，minCapacity为1，在Math.max()方法比较后，minCapacity 为10。
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity= Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}
   
 //判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);   
}

 // 数组缓冲区最大存储容量, 一些 VM 会在一个数组中存储某些数据--->为什么要减去 8 的原因
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);   //扩充当前容量的1.5倍
    if (newCapacity - minCapacity < 0)     
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)  
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

 // 私有方法：大容量分配，最大分配 Integer.MAX_VALUE
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) 
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

增加元素

 	// 增加指定的元素到ArrayList的最后位置
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount
        elementData[size++] = e;
        return true;
    }

    // 在这个ArrayList中的指定位置插入指定的元素，
    public void add(int index, E element) {
        rangeCheckForAdd(index);            //判断角标是否越界
        ensureCapacityInternal(size + 1);  // Increments modCount
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

    // 将一个集合的所有元素顺序添加（追加）到 list 末尾
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;     //要添加元素的个数
        ensureCapacityInternal(size + numNew);  //扩容
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    // 从 List 中指定位置开始插入指定集合的所有元素, list中原来位置的元素向后移，并不会覆盖掉在 index 位置原有的值
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        Object[] a = c.toArray();//是将list直接转为Object[] 数组
        int numNew = a.length;  
        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;
    }

  	// 添加时检查索引是否越界
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

移除元素

  // 移除指定位置的元素  
    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;//要移动的长度
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        elementData[--size] = null;
        return oldValue;
    }

    // 移除list中指定的第一个元素(符合条件索引最低的)
    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;
    }

    // 快速删除第 index 个元素，remove(int index)相比： 跳过检查，不返回被删除的值
    private void fastRemove(int index) {
        modCount++;//这个地方改变了modCount的值了
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        elementData[--size] = null; 
    }


    // 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;//要移动的数量
        System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);

        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        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;
    }

  // 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
  public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }


     //  返回此ArrayList实例的浅拷贝。 （元素本身不被复制） 
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

     // 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 
    public Object [] toArray() {
        return Arrays.copyOf(elementData, size);
    }

  /**
     *  a 需要存储 list 中元素的数组
     * 若 a.length >= list.size，则将 list 中的元素按顺序存入 a 中，a 中原有元素会被 list 的元素覆盖,然后 a[list.size] = null, a[list.size + 1] 及其  		   后的元素依旧是 a 的元素
     * 否则，将返回包含list 所有元素且数组长度等于 list 中元素个数的数组
     */
    @SuppressWarnings("unchecked") //告诉编译器忽略 unchecked 警告信息。
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    // 获取指定位置上的元素，从0开始
    public E get(int index) {
        rangeCheck(index);    //检查是否越界
        return elementData(index);
    }

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    // 返回在索引为 index 的元素：数组的随机访问

	@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    // 设置 index 位置元素的值,替换原有的元素值。
    public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);    //获取旧数值
        elementData[index] = element;
        return oldValue;
    }

序列化与反序列化

  	// 私有方法， 将ArrayList实例序列化
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{

        int expectedModCount = modCount;
        s.defaultWriteObject();  // 将当前类的非静态和非瞬态字段写入此流

        //写入clone行为的容量大小
        s.writeInt(size);

        //以合适的顺序写入所有的元素
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    // 私有方法，从反序列化中重构ArrayList实例
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        //读出大小和隐藏的东西
        s.defaultReadObject();

        // 从输入流中读取ArrayList的size
        s.readInt(); // ignored

        if (size > 0) {
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // 从输入流中将“所有的元素值”读出
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }
【项目实战】从0开始入门JDK源码 - ArrayList源码
本本本添哥
02-27 270
一般来说IDEA配置好JDK以后 ，JDK的源码其实也配置好了，本文是基于JDK1.8的源码说明 源码路径： rt - java - util - ArrayList
Collection - ArrayList 源码解析
qq_63353796的博客
06-13 765
本文主要对Collection - ArrayList进行源码解析。
Collection-ArrayList源码解析
最新发布
令狐_JackieHao的博客
10-10 1130
ArrayList的一点理解
Java集合-ArrayList源码解析
wx1458084829
12-16 1535
ArrayList 源码解析 底层数据结构
Java集合框架源码解读——Collection - ArrayList 源码解析
在路上
04-02 797
容器，就是可以容纳其他Java对象的对象。*Java Collections Framework(JCF)*为Java开发者提供了通用的容器，其始于JDK 1.2。Java容器里只能放对象，对于基本类型(int, long, float, double等)，需要将其包装成对象类型后(Integer, Long, Float, Double等)才能放到容器里。很多时候拆包装和解包装能够自动完成。这虽然会导致额外的性能和空间开销，但简化了设计和编程
【Collection - ArrayList 源码解析】
abclyq的博客
12-02 957
ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添加元素时，如果容量不足，容器会自动增大底层数组的大小。前面已经提过，Java泛型只是编译器提供的语法糖，所以这里的数组是一个Object数组，以便能够容纳任何类型的对象。
容器之ArrayList源码解析
weixin_43896141的博客
03-07 223
ArrayList源码解析 目录ArrayList源码解析定义的常量初始化扩容流程`ensureCapacity`不同的初始化方法的扩容过程 定义的常量 /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ private static final Object[] EM
容器-ArrayList源码分析
努力找工作呀
09-25 245
ArrayList概述 　ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。 ArrayList源码分析 1.ArrayList的继承和层次关系 ArrayList的UML类图： ...
Java 集合框架(2-9)-Collection - ArrayList 源码解析.pdf
07-03
《Java集合框架(2-9)-Collection - ArrayList 源码解析》 ArrayList是Java集合框架中的一个重要组件，它属于List接口的实现类，提供了一种动态数组的逻辑视图。ArrayList以高效、灵活的方式存储和操作对象序列，是...
读源码-VirtualView源码解析
SuperMing学习之路
06-01 522
文章目录1-基本原理2-源码解析2.1-xml模板描述2.2-xml模板编译2.3-.out预解析2.4-.out解析构建组件2.5-数据绑定与事件处理 1-基本原理 VirtualView是天猫出品的组件级别的动态化方案，通过动态下发xml模板到客户端，客户端完成模板解析、数据绑定、事件处理等实现动态化。实际常用的应用场景如下： 按照VirtualView SDK中的原生或拓展组件编写Xml模板，和Android中的布局xml类似 将Xml模板解析为二进制文件.out，和Android中xml文件解析
Java源码篇之容器类——ArrayList
12-20
本文将深入解析ArrayList的源码，帮助开发者理解其内部工作原理。 1、前言 在日常开发中，ArrayList是常用的数据结构之一，它允许我们在列表中按索引快速访问元素。由于它是基于数组实现的，因此插入和删除操作在...
xxl-job源码解析(技术分享)
李白
07-28 3693
紧接着执行监听器发送监听后，就会遍历所有的Bean然后初始化所有单例非懒加载的bean。分布式技术应用的时代，原生定时任务的缺陷显得更为突出。触发地址com.xxl.job.admin.controller.JobInfoController#triggerJob。JobApiController就为SpringMVC的Controller，负责接收请求映射。再来看看其RPC调用，采用的是HTTP传输协议，并采用了JSON作为序列化。接口，实现该接口的当spring容器初始完成，调用。...
源码分析之ArrayList容器
Java学习之乐的博客
03-30 399
package java.util; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator; import sun.misc.SharedSecrets; /** * Resizable-array implementation of the <tt>List</tt> interface. Impleme
容器源码分析之ArrayList(二)
heihei
01-09 228
ArrayList的类声明 首先看一下ArrayList的类声明 public class ArrayListE> extends AbstractListE> implements ListE>, RandomAccess, Cloneable, java.io.Serializable ArrayList类主要是继承AbstractList类并实现了
Java日志体系---JUL源码解析
热门推荐
玄灵斩仙剑的博客
02-18 2万+
在软件开发过程中日志记录是必不可少的一部分。作为一个合格的软件开发者（Java），有必要深入了解一下Java的日志体系。本文将详细的介绍我在学习JUL时的一些方法和心得。 一般来说日志分为两种：业务日志和异常日志，使用日志我们希望能达到以下目标： 对程序运行情况的记录和监控； 在必要时可详细了解程序内部的运行状态； 对系统性能的影响尽量小； 个人觉得记录日志最重要的目的在于记录程序运行的信...
retrofit应用详解与源码解析--源码解析
门心叼龙的专栏
08-05 526
retrofit是基于okhttp构建的，它的所有工作都是围绕Request和Response展开的，retrofit可以把一个接口中定义的方法通过注解把它适配成okhttp中所定义的请求命令，有了这个请求命令我们就可以发起一个同步请求和异步请求了 文章目录方法注解参数注解其他注解01.用户登录【@GET+@Query】02.用户注册【@POST+@Body】03.用户登录【@GET+@QueryMap】04.用户登录【@POST+@FormURLEncoded+@Field】05.用户登录【@POST.
Java源码解析ArrayList及ConcurrentModificationException
08-26
为了在遍历过程中修改ArrayList，可以使用`Iterator`的`remove()`方法，或者使用`CopyOnWriteArrayList`这样的线程安全容器。 总的来说，ArrayList在Java中是一个常用的动态数组实现，它提供了便捷的元素添加、删除...
ArrayList源码解析之初始化
I_LV_XJ的博客
02-03 495
在上一篇《ArrayList源码解析之架构》里面，对ArrayList的整体架构和数组的相关知识做了分享，本节将延续上节知识点，对ArrayList的源码进行分析。 1. ArrayList初始化方式 在开始介绍初始化之前，首先需要注意在源码中有两个空引用，如下图： EMPTY_ELEMENTDATA是一个共享空数组实例，当传入ArrayList构造器的容量为0时，用这个数组表示容器...
容器-ArrayList 源码学习
insider_way
06-02 87
Jdk 6260652 Bug 扩容 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >...
Java容器ArrayList源代码解析
Kevin_zhai的博客
05-18 897
ArrayList是很常用的一个容器，它的底层是用动态数组实现的，可以根据数据量大小自动扩容。它支持很多操作，比如向容器中添加、删除、查找数据，返回容器的大小等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值