学习过程：阅读ArrayList源码

最新推荐文章于 2022-08-21 17:23:08 发布
最新推荐文章于 2022-08-21 17:23:08 发布
阅读量313 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/InvisibleMouse/article/details/122902292
版权

前言

参考大佬：921天，从小厂到入职阿里。

JDK1.8 中 ArrayList 的源码有1400多行（注释估计占了一半），但是我们不需要全部看，我们只需要看其中重要的内容：基础属性、构造方法、get 方法、set 方法、add 方法、remove 方法、扩容方法等。

这篇文章是自己阅读源码的一个记录。如果能成为你的参考也是意外，最重要的还是自己去阅读源码，每人的体验与收获是不同的。

正文

类的注释

阅读类的注释可以得出以下几个要点：

  • 大小可变、允许所有类型的元素（包括null）、有方法可操作已用的数组

  • 方法：size、isEmpty、get、set、iterator、listIterator、add时间复杂度为O(1)

  • ArrayList里有一个capacity实例存储元素，可自动扩容

  • ensureCapacity方法可在添加大量元素之前扩大ArrayList的capacity（容量），从而减少扩容次数

  • 不同步（非线程安全）、 提供方法：List list = Collections.synchronizedList(new ArrayList(…))

  • 通过iterators（迭代器）遍历ArrayList时不是通过迭代器的remove、add方法修改，迭代器抛出ConcurrentModificationException异常。

  • 是Java Collection集合家族中的一员。

基础属性

//  默认容量大小：10
private static final int DEFAULT_CAPACITY = 10;
//  空实例的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//  空实例的默认大小数组；与EMPTY_ELEMENTDATA区别是添加第一个元素时要扩容的大小
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//  存储ArrayList 元素的数组缓冲区；ArrayList容量即数组大小
//  elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA添加第一个元素扩容到DEFAULT_CAPACITY大小
transient Object[] elementData; // non-private to simplify nested class access
//  当前ArrayList中存储元素个数记录
private int size;

注意：
EMPTY_ELEMENTDATA与DEFAULTCAPACITY_EMPTY_ELEMENTDATA是final类型，决定它们并不能存储元素，只是一个标识。

构造方法

1. 构造带有初始化容量大小的空list

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);
    }
}

initialCapacity：要初始化容量的值；非负数

2. 空构造

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

3. 带有初始值构造函数

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

c : 是实现Collection接口的类。

c.toArray()可能返回的并不是Object[]，所以需要特殊处理一下。

注：

1、<? extends E>： ？表示任意类、E表示泛型；

？是传入参数c中集合元素的类型，E是ArrayList规定的类型，即c集合元素的类型要是ArrayList中元素类型的本身或子类。

//  a中的元素时Integer类型，而c中的元素是Object类型；
//  Object extends Integer : 显然是错误的
LinkedList<Object> c = new LinkedList<>();
ArrayList<Integer> a = new ArrayList<>(c);

2、Arrays.copyOf()数组拷贝

扩容方法

ArrayList中几乎是最最重要的一个要点，所以我先看了它。

/**
  对外提供的方法。
  作用：确保ArrayList存储元素的数组大小要大于所需的最小容量。
  minCapacity：ArrayList存储元素的数组所需要的最小容量。
*/
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
    //  所需最小容量大于minExpand，扩容。【这里minExpand为0难以理解，可能需要思考一下这个方法用在何处】
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
  
/**
  数组扩容方法，用于类的内部；也是add()方法中使用的。
*/
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;  //  见名知意
    // minCapacity：ArrayList需要存储元素的最小容量， 
    // elementData.length：ArrayList存储元素的数组当前的长度
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  //  扩容
}

/**
  具体的扩容方法
*/
private void grow(int minCapacity) {
    // 原来的容量大小
    int oldCapacity = elementData.length;
    // >>: 右移， 右移一位等于除以2；所以容量大小为原来的1.5倍。
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 新的容量大小 < 所需的最小容量，替换赋值
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 属性：MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
  minCapacity超过最大可分配值情况的处理
*/
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

提醒：ArrayList中存储元素的是数据结构是数组，所以基本上，下面的方法你自己基本上都能实现。

get 方法

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}
//  get方法
public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}  
//  索引超出当前所存元素的最大长度校验
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

set 方法

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

add 方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 按序插在最后
    elementData[size++] = e;
    return true;
}
/**
  主要看一下index后的元素的移动是怎么实现的
*/
public void add(int index, E element) {
    //  见文知意，根据get中的校验就可以想到其实现方式
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
  
/**
  实质就是ensureExplicitCapacity这个方法。
*/
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //  这个方法是不是有点眼熟呢？
    ensureExplicitCapacity(minCapacity);
}

注： System.arraycopy()不止一次出现，如果尚未了解，可以提前了解一下其是怎么使用与实现的。

remove 方法

/**
  删除动作即赋null，剩下交给GC  
*/
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; // clear to let GC do its work
    return oldValue;
}
  
/**
  根据元素删除，从0开始遍历，删除第一个为o的元素；
*/
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;
}

removeAll()方法

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        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.
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

迭代器

在看ArrayList有关迭代器的方法前，先看一下其有关迭代器的内部类。

/**
 * An optimized version of AbstractList.Itr
 */
private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
    
    //  最终还是使用ArrayList的remove方法删除元素，但是删除后更新了expectedModCount值
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }
  
    //  禁止在使用迭代器遍历ArrayList时修改ArrayList。
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

/**
* An optimized version of AbstractList.ListItr
*/
private class ListItr extends Itr implements ListIterator<E> {
  ListItr(int index) {
      super();
      cursor = index;
  }

  public boolean hasPrevious() {
      return cursor != 0;
  }

  public int nextIndex() {
      return cursor;
  }

  public int previousIndex() {
      return cursor - 1;
  }

  @SuppressWarnings("unchecked")
  public E previous() {
      checkForComodification();
      int i = cursor - 1;
      if (i < 0)
          throw new NoSuchElementException();
      Object[] elementData = ArrayList.this.elementData;
      if (i >= elementData.length)
          throw new ConcurrentModificationException();
      cursor = i;
      return (E) elementData[lastRet = i];
  }

  public void set(E e) {
      if (lastRet < 0)
          throw new IllegalStateException();
      checkForComodification();

      try {
          ArrayList.this.set(lastRet, e);
      } catch (IndexOutOfBoundsException ex) {
          throw new ConcurrentModificationException();
      }
  }

  public void add(E e) {
      checkForComodification();

      try {
          int i = cursor;
          ArrayList.this.add(i, e);
          cursor = i + 1;
          lastRet = -1;
          expectedModCount = modCount;
      } catch (IndexOutOfBoundsException ex) {
          throw new ConcurrentModificationException();
      }
  }
}

ArrayList中有关迭代器方法

public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}

public ListIterator<E> listIterator() {
    return new ListItr(0);
} 
public Iterator<E> iterator() {
    return new Itr();
}

其他方法

trimToSize()： 将ArrayList的elementData缩小到所存元素的大小。
size()：见文知意。
isEmpty()：return size == 0
contains(Object o)：return indexOf(o) >= 0
indexOf(Object o)

//  for遍历，从0开始，所以返回的是第一个在elementData中出现为o的下标
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;阅读过程中产生的问题：
1、ArrayList()构造函数的执行

    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

lastIndexOf(Object o )：可以根据indexOf实现猜一下它的实现方式。
toArray()：return Arrays.copyOf(elementData, size)
clear()：还原到出厂状态 -

DOIT-HU
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ArrayList 源码阅读记录
Pzwdshxzt 的博客
08-03 404
ArrayList ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。 ArrayList不是线程安全的，只能用在单线程环境下 多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类 也可以使用concurrent并发包下的CopyOnWriteA...
18_ArrayList，LinkList链表接口实现-源码.zip
最新发布
06-01
通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入...
ArrayList源码阅读
qq_56460466的博客
08-21 83
ArrayList是我们经常使用到的集合。来阅读一下它的源码。
基于java-18_ArrayList，LinkList链表接口实现-源码.zip
05-08
通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入...
ArrayList源码阅读（上）
starexplode的博客
05-27 447
ArrayList源码阅读 ArrayList是使用比较多的一个List，它的底层实现是使用的是一个数组，从继承性来讲，它继承了AbstractList的接口，并实现了List、RandomAccess、Cloneable和Serializable序列化接口。 public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; imp...
ArrayList 源码阅读笔记
Boking的博客
10-13 511
ArrayList 源码阅读笔记目录接口简介源码阅读成员变量与构造函数trimToSizecapacitycontainsclonetoArrayaddremoveserializeiteratorsubSpliteratorforEachreplacesort 目录 主要继承和实现的类和接口 接口简介 RandomAccess public interface RandomAccess M...
ArrayList源码阅读笔记
三分恶的博客
08-16 718
简介 ArrayList是基于数组实现的一种列表。 ArrayList继承体系如下： 图一：ArrayList继承体系 ArrayList实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。 ArrayList实现了List，提供了基础的添加、删除、遍历等操作。 ArrayList实现了RandomAccess，提供了随机访问的能力。 ArrayList实现了Cloneable，可以被克隆。 ArrayList实现了Ser
Java核心复习 —— ArrayList源码阅读
CoffeJoy
04-23 158
dir
【Java容器】ArrayList源码阅读笔记
好好学习！
09-28 166
ArrayList是一个非常重要Java容器，下面是ArrayList的源码阅读笔记。 首先我们先看ArrayList继承的类和实现的接口 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable 我们可以看到ArrayList继承父类AbstractList，
阅读ArrayList源码
weixin_42571453的博客
03-02 284
ArrayList扩容的核心方法为：.grow方法，该方法具有两个构造器，无参构造器情况下，直接调用有参构造器； 有参构造器的作用如下： 定义，当前需要的长度为：minCapacity; 当前的真实长度为：oldCapacity = elementData.length; 那么，差值为： int differValue = minCapacity - oldCapacity; 为了减少扩容次数，则每次多扩容一点，可以选择扩原来长度的1.5倍，或者差值，扩容之后的长度为： int newCap..
ArrayList源码阅读分析
小智博客
10-13 92
一、ArrayList源码阅读分析 1.1 ArrayList介绍 ArrayList一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。 ArrayList 实现了RandmoAccess接口，即提供了
阅读ArrayList源码的一些记录
落魄书生已存在的博客
11-08 153
ArrayList的底层是基于数组实现的，但是我们知道数组的长度一旦确定就不能够再次变化，ArrayList的长度是可以变化的，其实就是在需要扩容的时候，重新生成一个数组，并把原数组中的元素放到新的数组中，用新的数组替代就得数组，就完成了ArrayList的扩容。 本文是基于JDK1.8的源码，同时也会提到一些和JDK1.6的一些差别 一、构造方法 1、给定初始大小的构造方法 public Arr...
ArrayList源码
09-21
### 回答1： 以下是Java中ArrayList类的部分源代码（摘自...总的来说，ArrayList的源码实现了动态数组的功能，根据需要自动扩容和缩容，提供了丰富的方法来增加、删除、获取元素，是Java集合框架中常用的一个类。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值