Java源码系统之ArrayList

最新推荐文章于 2023-12-28 08:45:00 发布
最新推荐文章于 2023-12-28 08:45:00 发布
阅读量135 收藏
点赞数
文章标签： java c/c++
原文链接：http://www.cnblogs.com/wanmeilingdu/p/11195608.html
版权

Java源码系列之ArrayList

一、介绍

java.util.ArrayList<E> 是非常重要的一个类，在代码中广泛使用，E表示泛型，ArrayList是一个泛型类。

ArrayList相当于C++ 的vector，用于存储对象。与数组不同，数组一旦创建，长度固定，但是ArrayList的长度是动态的，不受限制，可以存储任意多的对象，但是只能存储对象，不能存储原生数据类型例如int。 它的继承类图关系如下：

从图上可以看出，ArrayList继承了AbstractList，实现了List、Cloneable、Serializable、RandomAccess接口。

 

二、源码分析

基本属性

 /**
      * 默认初始容量，大小为10.
      */
  private static final int DEFAULT_CAPACITY = 10;
 ​
  /**
  * 空的数组，传入容量为0时使用.
  */
  private static final Object[] EMPTY_ELEMENTDATA = {};
 ​
  /**
  * 空的数组，传入容量时使用，当容器添加第一个元素时，会进行扩容，具体见add(E e)方法.
  */
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 ​
  /**
  * 真正存储元素的数组
  */
  transient Object[] elementData; // non-private to simplify nested class access
  
  /**
  * 要分配的数组的最大值
  */
  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

  • DEFAULT_CAPACITY ：默认容量为10，也就是通过new ArrayList()创建时的默认容量。

  • EMPTY_ELEMENTDATA ：空的数组，这种是通过new ArrayList(0)创建时用的是这个空数组。

  • DEFAULTCAPACITY_EMPTY_ELEMENTDATA：也是空数组，这种是通过new ArrayList()创建时用的是这个空数组，与EMPTY_ELEMENTDATA的区别是在添加第一个元素时使用这个空数组的会初始化为DEFAULT_CAPACITY（10）个元素。

  • elementData：真正存放元素的地方，使用transient是为了不序列化这个字段。

  • size：真正存储元素的个数，而不是elementData数组的长度。

  • MAX_ARRAY_SIZE：数组长度的最大值是Integer.MAX_VALUE - 8

    数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。

    如果数组长度过大，可能出现的两种错误

    OutOfMemoryError: Java heap space 堆区内存不足（这个可以通过设置JVM参数 -Xmx 来指定）。

    OutOfMemoryError: Requested array size exceeds VM limit 超过了JVM虚拟机的最大限制，我的window64就是 Integer.MAX_VALUE-1 .

构造方法之ArrayList(int initialCapacity)

     public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
  //如果传入的初始容量值大于0，则初始化一个初始容量大小的数组，用来存储元素
  this.elementData = new Object[initialCapacity];
  } else if (initialCapacity == 0) {
  //如果等于0，则把空数组EMPTY_ELEMENTDATA赋给elementData
  this.elementData = EMPTY_ELEMENTDATA;
  } else {
  //如果小于0，则抛出异常
  throw new IllegalArgumentException("Illegal Capacity: "+
  initialCapacity);
  }
  }

构造方法之ArrayList()

     public ArrayList() {
         //使用空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，在添加第一个元素的时候会扩容
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  }

构造方法之ArrayList(Collection<? extends E> c)

     public ArrayList(Collection<? extends E> c) {
  //传入的集合转为数组，并赋值给elementData
  elementData = c.toArray();
  //判断传入的集合的大小是否为0
  if ((size = elementData.length) != 0) {
  //判断集合toArray()返回的结果是否是Object[].class,如果不是，则重新拷贝成Object[].class类型
  if (elementData.getClass() != Object[].class)
  elementData = Arrays.copyOf(elementData, size, Object[].class);
  } else {
  //如果传入的集合为0，则初始化为空数组EMPTY_ELEMENTDATA
  this.elementData = EMPTY_ELEMENTDATA;
  }
  }

方法之add(E e)

     /**
     * 添加元素
  */
  public boolean add(E e) {
  //检查是否需要扩容
  ensureCapacityInternal(size + 1); // Increments modCount!!
  //添加元素到最后一位
  elementData[size++] = e;
  return true;
  }
 ​
  private void ensureCapacityInternal(int minCapacity) {
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  //如果elementData为空数组，则取默认容量和传入的所需最小容量(minCapacity)之中大的值
  //并把该值重新赋值给minCapacity
  minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  }
 ​
  ensureExplicitCapacity(minCapacity);
  }
 ​
  private void ensureExplicitCapacity(int minCapacity) {
  modCount++;
 ​
  // overflow-conscious code
  if (minCapacity - elementData.length > 0)
  //真正的扩容方法
  grow(minCapacity);
  }
 ​
  private void grow(int minCapacity) {
  // overflow-conscious code
  int oldCapacity = elementData.length;
  //新的容量是老容量1.5倍
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  if (newCapacity - minCapacity < 0)
  //如果新容量比所需最小容量小，则把所需最小容量值赋给新的容量
  newCapacity = minCapacity;
  if (newCapacity - MAX_ARRAY_SIZE > 0)
  //如果新容量要大于所允许的最大长度，则会使用最大容量为Integer的最大值，
  //否则使用MAX_ARRAY_SIZE
  newCapacity = hugeCapacity(minCapacity);
  //以新容量拷贝出来一个新数组
  elementData = Arrays.copyOf(elementData, newCapacity);
  }
 ​
  private static int hugeCapacity(int minCapacity) {
  if (minCapacity < 0) // overflow
  throw new OutOfMemoryError();
  return (minCapacity > MAX_ARRAY_SIZE) ?
  Integer.MAX_VALUE :
  MAX_ARRAY_SIZE;
  }

方法之add(int index, E element)

     /**
     * 添加元素到指定位置
  */
  public void add(int index, E element) {
  //检查是否越界
  rangeCheckForAdd(index);
  //检查是否需要扩容
  ensureCapacityInternal(size + 1); // Increments modCount!!
  //将下标为index及之后的元素向后移一位，这样index就空出来了
  System.arraycopy(elementData, index, elementData, index + 1,
  size - index);
  //将元素插入到index的位置
  elementData[index] = element;
  //大小加1
  size++;
  }
 ​
  private void rangeCheckForAdd(int index) {
  if (index > size || index < 0)
  throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }

方法之addAll(Collection<? extends E> c)

     /**
     * 求两个集合的并集
  */
  public boolean addAll(Collection<? extends E> c) {
  //将集合c转为数组
  Object[] a = c.toArray();
  //集合a的大小
  int numNew = a.length;
  //扩容所需的容量=已有数组的大小+c集合的大小
  ensureCapacityInternal(size + numNew); // Increments modCount
  //将集合c的元素，拷贝到数组的最后
  System.arraycopy(a, 0, elementData, size, numNew);
  //size加上c集合的大小
  size += numNew;
  //如果集合c不为空，返回true，否则返回false
  return numNew != 0;
  }

方法之get(int index)

     /**
     * 获取指定位置的元素
  */
  public E get(int index) {
  //检查是否越界
  rangeCheck(index);
  //返回数组index的元素
  return elementData(index);
  }
 ​
  private void rangeCheck(int index) {
  if (index >= size)
  throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }
  
  E elementData(int index) {
  return (E) elementData[index];
  }

注：获取指定索引位置的元素，时间复杂度为O(1)。

方法之remove(int index)

     /**
     * 删除指定位置元素
     */
  public E remove(int index) {
  //检查是否越界
  rangeCheck(index);
 ​
  modCount++;
  //获取index位置的元素
  E oldValue = elementData(index);
 ​
  int numMoved = size - index - 1;
  //如果index不是最后一位，则将index之后的元素往前挪一位
  if (numMoved > 0)
  System.arraycopy(elementData, index+1, elementData, index,numMoved);
  //讲最后一个元素删除，置空，帮助GC回收
  elementData[--size] = null; // clear to let GC do its work
  //返回旧值，即删除的index对应的值
  return oldValue;
  }

注：删除指定索引位置的元素，时间复杂度为O(n)；而且从源码上可以看出，删除元素后ArrayList并没有缩容。

方法之remove(Object o)

     /**
     * 删除指定元素值的元素
  */
  public boolean remove(Object o) {
  if (o == null) {
  //遍历整个数组，找到元素第一次出现的位置，并将其快速删除
  for (int index = 0; index < size; index++)
  //如果要删除的元素为null，则使用==进行比较，满足条件则进行快速删除，并返回true
  if (elementData[index] == null) {
  fastRemove(index);
  return true;
  }
  } else {
  //遍历整个数组，找到元素第一次出现的位置，并将其快速删除
  for (int index = 0; index < size; index++)
  //如果要删除的元素不为null，则使用equals进行比较，满足条件则进行快速删除，并返回true
  if (o.equals(elementData[index])) {
  fastRemove(index);
  return true;
  }
  }
  return false;
  }
 ​
  /*
  * Private remove method that skips bounds checking and does not
  * return the value removed.
  */
  private void fastRemove(int index) {
  //和remove(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
  }

方法之retainAll(Collection<?> c) 

     /**
     * 求两个集合的交集
  */
  public boolean retainAll(Collection<?> c) {
  //校验集合c是否为null，为null则抛出NullPointerException
  Objects.requireNonNull(c);
  //调用批量删除方法，这时complement传入true，表示删除不包含在c中的元素
  return batchRemove(c, true);
  }
 ​
  /**
  * 批量删除
  * @param c 集合
  * @param complement 为true，表示删除不包含在c中的元素，否则表示删除包含c中的元素
  * @return
  */
  private boolean batchRemove(Collection<?> c, boolean complement) {
  final Object[] elementData = this.elementData;
  //使用读写两个指针同时遍历数组
  //读指针每次自增1，写指针放入元素的时候才加1
  //这样不需要额外的空间，只需要在原有的数组上操作就可以了
  int r = 0, w = 0;
  boolean modified = false;
  try {
  //遍历整个数组，如果c中包含该元素，则把该元素放到写指针的位置（以complement为准）
  for (; r < size; r++)
  if (c.contains(elementData[r]) == complement)
  elementData[w++] = elementData[r];
  } finally {
  // Preserve behavioral compatibility with AbstractCollection,
  // even if c.contains() throws.
  //正常来说r最后是等于size的，除非c.contains()抛出了异常
  if (r != size) {
  //如果c.contains()抛出了异常，则把未读的元素都拷贝到写指针之后
  System.arraycopy(elementData, r,
  elementData, w,
  size - r);
  w += size - r;
  }
  if (w != size) {
  //将写指针之后的元素置为空，帮助GC回收
  for (int i = w; i < size; i++)
  elementData[i] = null;
  modCount += size - w;
  //新的大小等于写指针的位置，因为每写一次写指针就加1，所以新大小正好等于写指针的位置
  size = w;
  //有修改，设置modified=true
  modified = true;
  }
  }
  return modified;
  }

方法之removeAll(Collection<?> c)

     /**
     * 删除包含c集合的元素，即求差集
  */
  public boolean removeAll(Collection<?> c) {
  //检查集合c不能为null
  Objects.requireNonNull(c);
  //批量删除，complement为false，表示删除包含在c中的元素
  return batchRemove(c, false);
  }

elementData之序列化

 private void writeObject(java.io.ObjectOutputStream s)
  throws java.io.IOException{
  //防止序列化期间有修改
  int expectedModCount = modCount;
  //写出非transient非static属性（会写出size属性）
  s.defaultWriteObject();
 ​
  //写出元素个数
  s.writeInt(size);
 ​
  //依次写出元素
  for (int i=0; i<size; i++) {
  s.writeObject(elementData[i]);
  }
 ​
  //如果有修改，抛出异常
  if (modCount != expectedModCount) {
  throw new ConcurrentModificationException();
  }
 }
 ​
 private void readObject(java.io.ObjectInputStream s)
  throws java.io.IOException, ClassNotFoundException {
  //声明为空数组
  elementData = EMPTY_ELEMENTDATA;
 ​
  //读入非transient非static属性（会读取size属性）
  s.defaultReadObject();
 ​
  //读入元素个数，没什么用，只是因为写出的时候写了size属性，读的时候也要按顺序来读
  s.readInt();
 ​
  if (size > 0) {
  //计算容量
  int capacity = calculateCapacity(elementData, size);
  SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
  //检查是否需要扩容
  ensureCapacityInternal(size);
 ​
  Object[] a = elementData;
  //依次读取元素到数组中
  for (int i=0; i<size; i++) {
  a[i] = s.readObject();
  }
  }
 }

注：

查看writeObject()方法可知，先调用s.defaultWriteObject()方法，再把size写入到流中，再把元素一个一个的写入到流中。

一般地，只要实现了Serializable接口即可自动序列化，writeObject()和readObject()是为了自己控制序列化的方式，这两个方法必须声明为private，在java.io.ObjectStreamClass#getPrivateMethod()方法中通过反射获取到writeObject()这个方法。

在ArrayList的writeObject()方法中先调用了s.defaultWriteObject()方法，这个方法是写入非static非transient的属性，在ArrayList中也就是size属性。同样地，在readObject()方法中先调用了s.defaultReadObject()方法解析出了size属性。

elementData定义为transient的优势，自己根据size序列化真实的元素，而不是根据数组的长度序列化元素，减少了空间占用。

 

总结

  • ArrayList内部使用数组存储元素，当数组长度不够时进行扩容，每次加一半的空间，ArrayList不会进行缩容；

  • ArrayList支持随机访问，通过索引访问元素极快，时间复杂度为O(1)；

  • ArrayList添加元素到尾部极快，平均时间复杂度为O(1)；

  • ArrayList添加元素到中间比较慢，因为要搬移元素，平均时间复杂度为O(n)；

  • ArrayList从尾部删除元素极快，时间复杂度为O(1)；

  • ArrayList从中间删除元素比较慢，因为要搬移元素，平均时间复杂度为O(n)；

  • ArrayList支持求并集，调用addAll(Collection<? extends E> c)方法即可；

  • ArrayList支持求交集，调用retainAll(Collection<? extends E> c)方法即可；

  • ArrayList支持求单向差集，调用removeAll(Collection<? extends E> c)方法即可；

转载于:https://www.cnblogs.com/wanmeilingdu/p/11195608.html

weixin_30856725
关注
Java 集合框架：ArrayList 的介绍、使用、原理与源码解析
栗筝i的博客
06-17 5616
本文将从介绍 ArrayList 开始，详细探讨其使用方法、工作原理以及背后的源码实现，帮助读者深入理解并灵活运用 ArrayList，以提升编程效率和代码质量。 在接下来的部分中，我们将首先概述 ArrayList 的基本特性及其在 Java 集合框架中的地位。随后，通过实际代码示例展示如何创建、操作和管理 ArrayList。接着，我们会揭示 ArrayList 的内部工作机制，包括其底层数据结构、扩容策略和性能优化等方面的内容。最后，我们将深入分析 ArrayList 的源码，探讨其设计思想和实现细
Java基础底层-ArrayList源码分析
Huang1178387848的博客
11-25 228
一、前言 继承了什么类，实现了什么接口？作用是什么？ 实现了四个接口一个抽象类。它继承了AbstractList抽象类，实现了List、RandomAccess, Cloneable, Serializable接口 ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能 ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。 ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克
java arraylist 源代码_Java ArrayList源码剖析
weixin_29821223的博客
02-23 92
ArrayList总体介绍ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添加元素时，如果容量不足，容器会自动增大底层数组的大小。前面已经提过，J...
Java集合——ArrayList源码详解
weixin_30355437的博客
10-20 192
0.前言面试的时候常会被问到ArrayList和Vector的区别。要回答这个问题，首先得对ArrayList的源码进行彻底理解，带着这个问题开始今天的文章。本文原创，转载请注明出处：SEU_Calvin的博客。先对ArrayList的特性进行一个概述：（1）ArrayList内部使用数组来保存元素。可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地...
JAVA源代码-ArrayList
Terry_yuan的博客
08-02 160
ArrayList底层是用数据实现的，只不过它是可以自动扩容的，每次扩容大小newCapacity = oldCapacity + (oldCapacity >> 1); >>1等于向右移一位，也就是说newCapacity = oldCapacity + (oldCapacity / 2); 其它源码详细说明，下面的链接说的蛮清楚的，可以参考：https://blo...
java ArrayList源代码实现
classify233的博客
10-30 398
java ArrayList（线性表）源代码实现： 总结：1.ArrayList类中内置了一个 elementData数组，进行增删改查命令时，对数组进行增删改查。 2.elementData数组容量capacity初始为10，每次容量不够时，容量扩大为2倍。 3.ArrayList对象序列化（实现Serialization接口）时，先序列化数组元素个数size，在遍历序列整个数组元素。
Java源码篇之容器类——ArrayList
12-20
了解ArrayList的源码可以帮助我们优化代码，尤其是在处理大量数据时。 2、ArrayList的类关系 ArrayList是Java.util包下的一个类，它继承自AbstractList，并实现了List接口和Serializable接口。AbstractList提供了大...
java毕业设计之ArrayList，LinkList链表接口实现源码.zip
07-17
"yuanma"可能是项目源代码的目录或者压缩文件，其中包含了ArrayList和LinkedList的具体实现以及其他相关代码。 通过这个项目，学生不仅可以学习到ArrayList和LinkedList的数据结构和算法，还能实践Java编程、数据库...
Java 中模仿源码自定义ArrayList
08-31
在Java编程中，模仿源码自定义ArrayList是一个深入理解数据结构和Java集合框架的好方法。ArrayList作为Java集合框架的一部分，其内部实现基于动态数组。通过分析ArrayList的源码，我们可以学习到如何创建一个类似的...
Java集合系列之ArrayList源码分析
08-27
本文将深入ArrayList的源码，探讨其内部实现、构造方法以及增删改查操作。 1. **内部结构与构造方法** ArrayList的核心成员变量是一个Object类型的数组`elementData`，用于存储元素。数组的初始容量默认为10，可以...
Java集合类源代码 ArrayList
LEO
11-01 1283
Java集合arraylist源代码Arraylist的必备知识点方法详解源码 Arraylist的必备知识点 准确的来说，不是在无参来构造赋值10的，一开始new ArrayList();的时候是0，第一次调用add()方法的时候才赋值10的，ArrayList源码中就有。 方法详解 源码 package java.util; public class ArrayListextends AbstractList implements List, RandomAccess,
Java源码之ArrayList
walker lee
12-21 2237
Java源码之ArrayList 转载请注明出处：http://blog.csdn.net/itismelzp/article/details/50371326 一、ArrayList概述 ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵
java ArrayList源代码详解
persistence_PSH的博客
03-26 153
类定义 //出现于jdk1.2，继承于AbstractList，实现了list接口，可克隆，可序列化，支持快速随机访问 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{} 变量 //默认初始容积 private static final int DEFAULT_C
JAVA源码系列-ArrayList
团子
07-29 337
前言 ArrayList是一个基于数组的数据结构，Java1.8版本加入了Lambda匿名内部类的新特性。而ArrayList实现了java.util.function的接口，进而为了支持Lambda表达式的应用。对于集合类来说，集合内部扩容机制，数据结构，并发场景，锁机制是我们日常所要面对思考的。废话不多说，现在我们来解析一下ArrayList的源码。  * 概述：  * List接口可调...
java的List、ArrayList源码详解
悦分享
09-04 476
java的List、ArrayList源码详解 List类的定义 public interface List<E> extends Collection<E> { // Query Operations int size(); boolean isEmpty(); boolean contains(Object o); I...
Java源码分析之ArrayList
博采众长，自成一派；
10-12 396
Java数据结构内部实现原理分析之ArrayList 文章目录Java数据结构内部实现原理分析之ArrayList前言ArrayList简介ArrayList是什么常见方法的时间复杂度概述动态增长概述非同步性遍历器ArrayList详解如何存储元素默认容量最大容量存储数组构造函数容量函数trimToSizeensureCapacitygrownewCapacityhugeCapacity索引函数操...
JDK17：Java ArrayList源码解读
最新发布
时代各有不同，青春一脉相承。
12-28 567
JDK17：Java ArrayList源码解读。 ArrayList是List接口的实现类，底层基于数组实现，容量可根据需要动态增加，相当于动态数组。ArrayList继承于AbstractList，并且还实现了Cloneable、Serializable、RandomAccess接口。List：表明是列表数据结构，可以通过下标对元素进行添加删除或查找。Serializable：表示可以进行序列化和反序列化操作，可以把对象与字节流相互转换。
Java集合——ArrayList源码解析
松仔Log的博客
12-11 1601
ArrayList源码解析ArrayList是什么？继承结构域构造函数扩容获取大小和判空截断克隆转为数组操作集合是否包含元素和获取下标获取元素设置元素添加元素添加集合删除单个元素删除范围元素求差集和交集全清序列化和反序列化获取迭代器迭代器——Itr内部类迭代器——ListItr内部类forEach和spliterator()不讲获取子串字串——SubList类（以下是类介绍）继承结构域构造函数设置元素获取元素获取大小添加元素删除元素获取迭代器获取子串的子串子串spliterator（子串没有重写forEac
Java重要类详解之ArrayList类
生命奇迹泉的专栏
09-23 5092
一.ArrayList概述 ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess[随机访问], Cloneable[可克隆], java.io.Serializable[序列化]这些接口。ArrayList 继承了AbstractList，实现了List。它是
深度解析Java ArrayList源码
"对Java编程中ArrayList的源码进行了深度解析，涵盖了ArrayList的基本操作以及核心实现原理，重点关注JDK1.8版本的实现。虽然没有详细解释迭代器SubList部分，但详细注释了ArrayList本身的实现，有助于理解其内部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值