ArrayList源码分析

最新推荐文章于 2024-08-22 16:13:15 发布
最新推荐文章于 2024-08-22 16:13:15 发布
阅读量263 收藏
点赞数
分类专栏： Java 文章标签： ArrayList详解 源码分析 扩容机制 copyOf和arraycopy 实现原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MOKEXFDGH/article/details/88575150
版权

文章目录

ArrayList 简介

  • ArrayList 的底层是数组队列（动态数组），其容量能动态增长。
  • 继承了 AbstractList，实现了List，具备了相应的增删改查等操作。
  • 实现了 RandomAcces 接口，使得该集合支持随机访问。
  • 实现 Cloneable 接口，覆盖了 clone()，能被克隆。
  • 实现了 Serializable 接口，支持序列化。
  • ArrayList 不是线程安全的，多线程可以使用 Vector。

源码解析

继承实现

		public class ArrayList<E> extends AbstractList<E>
        		implements List<E>, RandomAccess, Cloneable, java.io.Serializable

由简介可知，继承 AbstractList，实现 RandomAccess, Cloneable, java.io.Serializable。

属性

		//指定serialVersionUID用于指定序列化对象
		private static final long serialVersionUID = 8683452581122892189L;
		//默认初始容量大小
		private static final int DEFAULT_CAPACITY = 10;
		//空数组，用于空实例（给定初始容量0）
		private static final Object[] EMPTY_ELEMENTDATA = {};
		//
		private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
		//保存数据的数组
		transient Object[] elementData;
		//包含元素的个数
		private int size;
		//最大的数组大小，用于扩容判断
		private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

构造方法

默认构造方法：

		//默认构造方法
		//DEFAULTCAPACITY_EMPTY_ELEMENTDATA为空，只有添加第一个元素时才初始化为10
		public ArrayList() {
	        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	    }

指定容量的构造方法：

		public ArrayList(int initialCapacity) {
	        if (initialCapacity > 0) {
	            //已经给的容量创建数组
	            this.elementData = new Object[initialCapacity];
	        } else if (initialCapacity == 0) {
	            //创建空数组
	            this.elementData = EMPTY_ELEMENTDATA;
	        } else {
	            throw new IllegalArgumentException("Illegal Capacity: "+
	                                               initialCapacity);
	        }
	    }

包含指定集合的构造方法：

		public ArrayList(Collection<? extends E> c) {
	        //将集合存到数组中
	        elementData = c.toArray();
	        //如果其元素个数不为0
	        if ((size = elementData.length) != 0) {
	            //c.toArray()返回的不是Object类型，则将变为Object[]类型并重新存到数组中
	            if (elementData.getClass() != Object[].class)
	                elementData = Arrays.copyOf(elementData, size, Object[].class);
	        } else {
	            // 元素个数为0则用空数组代替
	            this.elementData = EMPTY_ELEMENTDATA;
	        }
	    }

扩容机制

当插入的数据量已知时，我们可以自行调用ensureCapacity：

		public void ensureCapacity(int minCapacity) {//minCapacity是所需的最小容量
	        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
	            ? 0: DEFAULT_CAPACITY;
	        if (minCapacity > minExpand) {
	            ensureExplicitCapacity(minCapacity);
	        }
	    }

而在我们添加元素获取所需最小容量时，则是使用：

		//首先得到最小扩容量（minCapactiy在方法调用处如add，会自行计算出来）
	    private void ensureCapacityInternal(int minCapacity) {
	        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//判断是否为空
	              // 获取默认的容量10和传入参数的较大值
	            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
	        }
	        ensureExplicitCapacity(minCapacity);
	    }

上面两个方法都会调用ensureExplicitCapacity来判断是否进行扩容：

		private void ensureExplicitCapacity(int minCapacity) {
	        modCount++;//记录修改次数，多用于非线程安全的集合，便于检验是否修改出错
	        if (minCapacity - elementData.length > 0)//如果大于0则说明需要进行扩容
	            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
	            grow(minCapacity);
	    }

扩容的核心方法 grow(minCapacity)：

		private void grow(int minCapacity) {
	        // oldCapacity为旧容量，newCapacity为新容量
	        int oldCapacity = elementData.length;
	        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
	        int newCapacity = oldCapacity + (oldCapacity >> 1);
	        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
	        if (newCapacity - minCapacity < 0)
	            newCapacity = minCapacity;
	        //再检查新容量是否超出了ArrayList所定义的最大容量，
	        //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
	        if (newCapacity - MAX_ARRAY_SIZE > 0)
	            newCapacity = hugeCapacity(minCapacity);
	        //创建新数组长度为newCapacity，并将原来的数据拷贝回去
	        elementData = Arrays.copyOf(elementData, newCapacity);
	    }
	     //比较minCapacity和 MAX_ARRAY_SIZE
	    private static int hugeCapacity(int minCapacity) {
	        if (minCapacity < 0) 
	            throw new OutOfMemoryError();
	        //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新容量大小则为MAX_ARRAY_SIZE。
	        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
	    }

常用方法

		//获取元素个数
		public int size() {
	        return size;
	    }
		
		//判断有无元素
		public boolean isEmpty() {
	        return size == 0;
	    }
		
		//判断是否包含
		public boolean contains(Object o) { 
	        return indexOf(o) >= 0;
	    }
	    
	    //返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
	    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++)
	                //equals()方法比较
	                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;
	    }
		//获取指定位置元素
		public E get(int index) {
	        rangeCheck(index);//对index进行界限检查
	        return elementData(index);
	    }
		
		//指定位置替换为指定元素，并返回旧元素
		public E set(int index, E element) {
	        rangeCheck(index);
	        E oldValue = elementData(index);
	        elementData[index] = element;
	        //返回原来在这个位置的元素
	        return oldValue;
	    }

		//添加指定元素到末尾
		public boolean add(E e) {
			//判断是否需要扩容
	        ensureCapacityInternal(size + 1);  
	        elementData[size++] = e;
	        return true;
	    }

		//指定位置添加
		public void add(int index, E element) {
	        rangeCheckForAdd(index);
	        ensureCapacityInternal(size + 1);
	        System.arraycopy(elementData, index,elementData, index + 1,size - index);
	        //区别copyOf()
	        elementData[index] = element;
	        size++;
	    }
		//指定位置删除
		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;
	    }

		//删除指定元素的第一个出现
		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;
	    }

		//删除所有元素
		public void clear() {
	        modCount++;
	        // 把数组中所有的元素的值设为null
	        for (int i = 0; i < size; i++)
	            elementData[i] = null;
	        size = 0;
	    }

		//从此列表中删除指定集合中包含的所有元素。 
	    public boolean removeAll(Collection<?> c) {
	        Objects.requireNonNull(c);
	        //如果此列表被修改则返回true
	        return batchRemove(c, false);
	    }
	
	    //仅保留此列表中包含在指定集合中的元素。
	    public boolean retainAll(Collection<?> c) {
	        Objects.requireNonNull(c);
	        return batchRemove(c, true);
	    }
		
		//从前往后将集合转为数组
		 public Object[] toArray() {
	        return Arrays.copyOf(elementData, size);
	    }

其它方法

		//修改容量为元素个数一样
		public void trimToSize() {
	        modCount++;
	        if (size < elementData.length) {
	            elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
	        }
	    }

		//将指定集合中所有元素添加到末尾
		public boolean addAll(Collection<? extends E> c) {
	        Object[] a = c.toArray();
	        int numNew = a.length;
	        ensureCapacityInternal(size + numNew);  // Increments modCount
	        System.arraycopy(a, 0, elementData, size, numNew);
	        size += numNew;
	        return numNew != 0;
	    }

		//将指定集合中所有元素添加到指定位置
		public boolean addAll(int index, Collection<? extends E> c) {
	        rangeCheckForAdd(index);
	
	        Object[] a = c.toArray();
	        int numNew = a.length;
	        ensureCapacityInternal(size + numNew);  // Increments modCount
	
	        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;
	    }

		//删除某段的所有元素。fromIndex-toIndex
		 protected void removeRange(int fromIndex, int toIndex) {
	        modCount++;
	        int numMoved = size - toIndex;
	        System.arraycopy(elementData, toIndex, elementData, fromIndex,
	                         numMoved);
	
	        // clear to let GC do its work
	        int newSize = size - (toIndex-fromIndex);
	        for (int i = newSize; i < size; i++) {
	            elementData[i] = null;
	        }
	        size = newSize;
	    }

		//检查给定索引是否在范围内（get、set）
		private void rangeCheck(int index) {
	        if (index >= size)
	            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	    }
		//检查给定索引是否在范围内（add、addAll）
		private void rangeCheckForAdd(int index) {
	        if (index > size || index < 0)
	            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	    }

迭代器

内部类：

		private class Itr implements Iterator<E>  
	    private class ListItr extends Itr implements ListIterator<E>  
	    private class SubList extends AbstractList<E> implements RandomAccess  
	    static final class ArrayListSpliterator<E> implements Spliterator<E>

相关方法：

		//以正确的顺序返回该列表元素的迭代器
		public Iterator<E> iterator() {
	        return new Itr();
	    }

		//返回按照适当的顺序的迭代器
		public ListIterator<E> listIterator() {
	        return new ListItr(0);
	    }
		
		//返回从指定位置开始的迭代器
		public ListIterator<E> listIterator(int index) {
	        if (index < 0 || index > size)
	            throw new IndexOutOfBoundsException("Index: "+index);
	        return new ListItr(index);
	    }

arraycopy和copyOf区别

在指定位置添加元素时：

		public void add(int index, E element) {
	        rangeCheckForAdd(index);
	        ensureCapacityInternal(size + 1);
	        //arraycopy()方法实现数组自己复制自己
	        //elementData:源数组;index:源数组中的起始位置;
	        //elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
	        System.arraycopy(elementData, index, elementData, index + 1, size - index);
	        elementData[index] = element;
	        size++;
	    }

使用arraycopy实现了数组自己复制自己，并index后面的元素都后移一位。

联系和区别：
联系：copyyOf()方法内部其实也是调用的 arraycopy() 方法
区别：

  • arraycopy()方法需要源数组和目标数组，且能根据位置进行复制拷贝。
  • copyOf()方法则只需要源数组，将其中元素复制到新的数组中并返回。
MOKE_XR
关注
专栏目录
【Java】ArrayList源码分析
qq_39921135的博客
07-02 855
假设集合第一次新建的长度为10的数组已经装满了，然后此时我需要一次性添加100个数据，很显然，长度为10的数组扩容1.5倍为15个数据的数组，肯定不够，此时新数组的长度就以实际情况为准：110（原来的10个 + 新增加的100个数据）。当原来10个元素的数组存满时，它会创建一个新的数组，新数组长度是原来的1.5倍，也就是长度为15。当我们不断的添加，数组里面的元素存满了，这个时候如果需要继续再存，在底层就需要自动扩容。这个类的源码比较多，看起来不太方便，因此我们需要将它的大纲视图罗列出来，有两种办法。
ArrayList 源码分析
搬运Gong
03-23 980
ArrayList的初始化过程及动态扩容机制源码分析
Java 集合—— ArrayList 源码分析
最新发布
weixin_44814196的博客
08-22 829
分析 ArrayList 的底层数据结构和扩容机制。
java ArrayList源码分析（深度讲解）
Cyan_RA9的博客
03-13 1938
java 集合篇章——ArrayList类源码分析。通过Debug一步一步带你看懂源码!
【源码】ArrayList 源码分析
来到人间不过是个蹭饭的客人，还挑什么酸甜苦辣。
06-22 453
本文主要介绍了ArrayList的相关知识，底层数据结构，数组集合相互转换，源码主要分析了其扩容机制。
ArrayList源码分析（超详细）
一条咸鱼的博客
10-05 2226
ArrayList源码详解，面试官：“嗯，回去等通知吧。”
Java编程中ArrayList源码分析
08-28
Java编程中ArrayList源码分析 Java编程中ArrayList源码分析是Java编程中一个重要的知识点，对于Java开发者来说，了解ArrayList的源码可以帮助他们更好地理解Java集合框架的实现机制，从而提高自己的编程水平。 ...
ArrayList源码分析(含jdk1.8).pdf
04-24
在了解ArrayList的源码分析时，我们主要探讨其在Java Development Kit (JDK) 1.8中的实现。ArrayList是一个非常重要的集合框架，用于动态数组的实现，其功能类似于数组，但可以在运行时动态调整大小。它是一个非线程...
Java基础学习笔记（完整版）
MOKE_SPACE
05-12 3957
弱弱的大学党也想学一下写写博客，记录下自己的学习足迹。 虽然也许记录的东西都很浅显，但也希望有人能撇到我的博客，揪揪我笔记的错误或者补充下我没有注意到的知识点。 注：第一次写，排版可能比较辣眼睛，还望多多包涵。 / /大概也许估计也没人会看ಥ_ಥ 目前情况 暂定学习路线： 基础√-接口√-常用类√-GUI√-异常处理√-集合框架√-IO流–HTML-CSS-JavaScrip...
Java8新特性之Stream API
MOKE_SPACE
07-25 1105
概述 Stream API 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。总得来说，Stream API 就是提供了一种高效且易于使用的处理数据的方式。 注：需要会使用 Lambda 表达...
学习总结BIO,NIO,AIO
MOKE_SPACE
05-05 774
文章目录BIO,NIO,AIO 的概念BIO介绍实现NIO介绍 BIO,NIO,AIO 的概念 Java 中的 BIO、NIO和 AIO 理解为是 Java 语言对操作系统的各种 IO 模型的封装。 同步阻塞IO（BIO）： 用户进程发起一个IO操作以后，必须等待IO操作的真正完成后，才能继续运行； 同步非阻塞IO（NIO）： 用户进程发起一个IO操作以后，可做其它事情，但用户进程需要经常询问...
Java 中线程池的原理与源码浅析
MOKE_SPACE
09-22 749
在 并发编程 中，我们只介绍了几种常用的线程池，以及它们的使用，那线程池是如何管理一组线程的呢？ 介绍 先来看下关系图： 图片来源网络 从图中我们可以看出，之前我们学习的几个常用的线程池 CachedThreadPool、FiedThreadPool 等都是通过 Executors 调用创建的： ExecutorService pool = Executors.newCachedThreadP...
HashMap源码分析
MOKE_SPACE
03-18 591
文章目录HashMap简介底层数据结构JDK 1.8 之前JDK 1.8 之后源码分析属性节点类构造方法put 方法get 方法resize 方法 HashMap 简介 基于哈希表的 Map 接口实现，用于存放键值对 JDK1.8之前由数组（主体）、链表（解决哈希冲突）组成，而1.8之后当链表长度大于8时，会将链表转为红黑树，以减少搜索时间。 红黑树详解：地址 底层数据结构 JDK 1.8...
Java基础回顾
MOKE_SPACE
03-05 510
文章目录Java基础面向过程与面向对象的区别JVM、JDK 和 JRE 的区别重写和重载的区别面向对象三大特性String、StringBuffer 和 StringBuilder 的区别自动装箱和拆箱接口和抽象类的区别== 与 equals 的区别hashCode 与 equals按值传递线程与进程的区别常见关键字总结 Java基础 面向过程与面向对象的区别 面向过程 优点：因为不需要经常实例...
java基础知识补充3
MOKE_SPACE
02-06 384
文章目录BeanFactory配置文件使用方法Dao应用Service应用Servlet3.0注解替代配置文件(web.xml)异步处理对上传的支持动态代理newProxyInstanceClassLoaderInvocationHandler动态代理的实用类加载器概述类加载器的代理模式（委托机制）自定义类加载器（了解）Tomcat的类加载器 BeanFactory BeanFactory是一个...
Java8新特性之Lambda表达式和方法引用
MOKE_SPACE
07-25 347
Lambda表达式 Lambda表达式是 Java 8 新特性中的一种新的语法形式，首先我们先来看下它的例子： (String s) -> System.out.println(s) 格式： 参数列表 -> 函数主体（可有返回类型 / 抛出异常） 我们可以将 Lambda 表达式理解为是一个函数，这个函数的特点是匿名（没有名称）且可传递（作为方法参数）的。 而可传递是如何表现的...
JavaEE知识回顾
MOKE_SPACE
03-06 311
文章目录Servlet生命周期GET 与 POST 请求的区别转发、重定向和刷新JSP 和 Servlet 的关系JSP九大内置对象，七大动作，三大指令实现会话跟踪的技术 参考：地址 Servlet 作用： Servlet 用于负责接收用户的请求（HttpServletRequest），并在 doGet() 或 doPot() 中做相应的处理，并通过HttpServletResponse 响应给...
深度解析Java ArrayList源码
以下是对ArrayList源码中关键部分的分析： 1. **数据结构**： ArrayList底层使用一个Object类型的数组`elementData`来存储元素。当数组满时，会通过扩容机制自动创建一个新的更大的数组并将原有元素复制过去。 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值