ArrayList源码分析

最新推荐文章于 2022-05-05 20:28:23 发布
最新推荐文章于 2022-05-05 20:28:23 发布
阅读量270 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41922289/article/details/96414531
版权

文章目录

1、数组介绍

数组是数据结构中很基本的结构，很多编程语言中都内置数组

数组是一片连续的内存区域，数组由数值和位置索引组成，所以可以根据索引将内存中的数值取出来，只有类型相同的数据才能一起存储到数组中

数组的优缺点：

  • 顺序存储，存储数据的内存是连续的
  • 查找数据容易，增删数据效率低下

2、ArrayList源码分析

1.构造方法

相关参数

    //默认容量
    private static final int DEFAULT_CAPACITY = 10;
    //默认空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //默认空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //不参与序列化的数组
    transient Object[] 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();
        //判断数组长度是否是空
        if ((size = elementData.length) != 0) {
            //数组不空，传进来的是有元素的集合
            //判断是否是Object[]类型
            if (elementData.getClass() != Object[].class)
                //如果不是Object[]，就返回一个包含相同元素的Object[]类型数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //否则则返回空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

2.数据插入

因为ArrayList是基于数组实现的，数组呢，又是固定容量的，那么，在数据添加的问题上必然会涉及到扩容的问题，毕竟，默认大小只有10而已

先看看ArrayList的扩容操作

    private void grow(int minCapacity) {
        // 原来的数组容量 = 数组长度
        int oldCapacity = elementData.length;
        // 新的数组容量 = 原数组容量+原数组容量/2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //判断下传进来的最小容量 （最小容量 = 当前数组元素数目 + 1）
        // 如果比当前新数组容量小，则使用最容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果判断当前新容量是否超过最大的数组容量 MAX_ARRAY_SIZE =  Integer.MAX_VALUE - 8
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //开始扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    //如果判断当前新容量是否超过最大的数组容量 MAX_ARRAY_SIZE =  Integer.MAX_VALUE - 8
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //如果超多最大数组容量则使用Integer的最大数值，否则还是使用最大数组容量
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

在谈数组拷贝

    elementData = Arrays.copyOf(elementData, newCapacity);

    //参数情况：原数组，新的数组长度
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

    //参数情况：原数组，新数组长度，数组类型
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        //判断当前数组类型是不是Object[]，根据指定类型构建数组（反射）
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        //本地方法：参数情况：（原数组， 原数组的开始位置， 目标数组， 目标数组的开始位置， 拷贝个数）
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

copyOf方法里的copy已经是扩容完成的数组，但是还是一个没有任何元素的数组，而下边的

        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));

则将原数组中的元素拷贝到扩容完成的数组

扩容1.5倍

扩容流程图

判断是否需要扩容，传入最小容量 = 当前数组容量 + 1

    ensureCapacityInternal(size + 1); 

    //判断是否需要扩容
    private void ensureCapacityInternal(int minCapacity) {
        //先计算容量
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

计算容量

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //如果是空数组，则返回默认容量10和传进来的最小容量的最大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //否则返回当前最小容量 ： 当前数组容量 + 1
        return minCapacity;
    }

开始扩容

    private void ensureExplicitCapacity(int minCapacity) {
        //修改数增+1 快速失败机制
        modCount++;

        //如果增加后的数组容量（size+1）> 原数组容量则需要扩容
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }

然后具体扩容的方法和步骤就走上面扩容的流程

在这里插入图片描述

了解完扩容，接下来看数据的添加会容易理解些

再线性表末端增加指定元素

    //最坏时间复杂度：O(1)
    public boolean add(E e) {
        //判断是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //线性表末端新增元素
        elementData[size++] = e;
        return true;
    }

在线性表指定位置增加指定元素

    //最坏时间复杂度：O(N)
    public void add(int index, E element) {
        //检查指定下标是否越界
        rangeCheckForAdd(index);
        //判断是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //移动线性表中指定下标后一位开始到最后一个元素中的元素，移动一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //空出来的位置即index下标位置则插入新元素
        elementData[index] = element;
        //数组容量+1
        size++;
    }

3.数据删除

指定下标删除

    //最坏时间复杂度：O(N)
    public E remove(int index) {
        //检测下标是否越界
        rangeCheck(index);
        //修改数+1
        modCount++;
        //先取出要删除的元素（根据索引找出元素）
        E oldValue = elementData(index);
        //要移动的元素数量，即将index后得元素（不包括index）先向index方向移动一位，覆盖要被删除的index下标对应的元素
        int numMoved = size - index - 1;
        //要移动的元素数量>0则表示有元素要删除
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        //清除最后一个元素
        elementData[--size] = null; // clear to let GC do its work
        //返回被删除元素的数值
        return oldValue;
    }

指定下标快速删除

    //最坏时间复杂度：O(N)
    //只是一个私有方法，会跳过越界检查并且不会返回被删除元素的数值
    private void fastRemove(int index) {
        //思路和根据指定下标删除的remove方法一样，只是缺少了越界的检查
        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
    }

指定元素删除

    //最坏时间复杂度：O(N^2)
    public boolean remove(Object o) {
        //判断要删除的元素是否是null,侧面反映ArrayList的add方法可以增加null元素
        if (o == null) {
            //如果是空，则遍历线性表找出所有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;
                }
        }
        //没有匹配元素则返回null
        return false;
    }

4.ArrayList的迭代器

先从一个遍历问题开始看起

java集合的遍历细分可以有三种方式

1.简单循环遍历

List<Integer> list = new ArrayList<>();
for(int i = 0;i<list.size();i++){
    //遍历
}

2.使用迭代器遍历

List<Integer> list = new ArrayList<>();
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    iterator.next();//遍历
}

3.使用增强for循环遍历

List<Integer> list = new ArrayList<>();
for(int i : list){
    //遍历
}

在看使用迭代器遍历和使用增强for循环遍历的差异

能够使用增强for循环遍历的都是实现了Iterable接口的实现类
该接口是对迭代器即Iterator的一个包装

public interface Iterable<T> {
    Iterator<T> iterator();
}

为什么需要对其进行包装？

因为Iterator是迭代器类，核心方法是hasNext(),next(),remove()都依赖于当前位置，如果集合类直接实现迭代器接口，则集合类需要维护多一个变量来指向当前迭代位置，不然当集合在方法间传递时，next执行的值即下一个迭代的值不能确定，但是，如果在Iterable的包装下，每次迭代都会返回一个新的从头开始的迭代器

获取迭代器

public Iterator<E> iterator() {
        return new Itr();
    }

ListIterator是Iterator的一个子接口

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

ArrayList中的迭代器是以内部类的形式存在

先关注几个重点变量

        int cursor;       // 指向下一个被迭代元素的指针（或者说是其下标）
        int lastRet = -1; // 指向迭代器最后一次取出的元素的位置。或没有元素时取-1
        int expectedModCount = modCount;//修改期望值

关于expectedModCount和modCount的补充

在集合的add，remove等操作时，modCount都会+1，而在集合遍历中只有保证expectedModCount = modCount才算是合法的遍历，不然会报错ConcurrentModificationException

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

看看合法遍历和不合法的遍历

不合法遍历，在遍历过程中使用集合的add，remove方法

List<Integer> list = new ArrayList<>();
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    int i = iterator.next();//遍历
    if(i == 12){
        list.remove(12);//集合的add，remove不能保证expectedModCount = modCount
    }
}

合法遍历，在遍历过程中使用迭代器的add，remove方法

List<Integer> list = new ArrayList<>();
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    iterator.next();//遍历
    if(i == 12){
        iterator.remove(); //迭代器的remove可以保证expectedModCount = modCount
    }
}

所以在进行集合元素的遍历时最好还是使用迭代的remove和add方法，更加符合规范和安全

深究迭代器的remove和hasNext，和next方法

hasNext()

        public boolean hasNext() {
            //判断指向当前迭代位置的（下标）的指针是否已经指向数组末尾
            return cursor != size;
        }

next()

        public E next() {
            checkForComodification();
            // i = 当前迭代位置下标
            int i = cursor;
            //检查i的合法性
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            //每迭代一次，i往后移动一位，cursor+1
            cursor = i + 1;
            //根据下标取元素
            return (E) elementData[lastRet = i];
        }

remove()

        public void remove() {
            //检查前驱指针是否合法
            if (lastRet < 0)
                throw new IllegalStateException();
            //检查期望修改值是否等于修改值
            checkForComodification();

            try {
                //其实还是使用arrayList的remove(),此时expectedModCount和modCount是不相等的
                ArrayList.this.remove(lastRet);
                //移动指针，后继指针指向刚刚删除元素的前驱
                cursor = lastRet;
                lastRet = -1;
                //更新expectedModCount，保证其相等
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

看完最基本的迭代器，可以看看list自身自定义的一个迭代器

private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }
        ...

可以看出，该迭代器是一个从指定位置开始进行迭代的迭代器，而且该迭代器还实现了基本迭代器没有的set 和 add 方法

        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源码中的基本知识算是整理完了吧，可能会有不全，但是还是想说，长文警告！

Kevin_cai09
关注
专栏目录
[集合]ArrayList源码解析(8.1)
谙忆-陈浩翔
04-08 1164
ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能 ArrayList...
ArrayList 源码分析
MG
04-02 1185
ArrayList 源码分析 版本：JDK 1.8 ArrayList list = new ArrayList(5); list.add('a'); list.add('b'); list.add('c'); list.add('d'); list.add('e'); list.add('f'); list.add('g'); Debug 继承关系如下： // 默认初
ArrayList源码详解
ITxiaofeixiang的博客
05-05 385
ArrayList源码详解 ArrayList作为开发最最常用的容器，了解并掌握其底层原理是每个开发人员必备的技能。 一、关键属性 /** * Default initial capacity. * 默认初始化容量 */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. * 空数组，用于空的实例化 */ private sta
ArrayList源码解读
阿星的博客
06-11 180
ArrayList源码解读 底层数据结构 ArrayList是在底层维护了一个elementData数组，添加了自动扩容等功能，最终形成了一个动态数组。 基本属性 // 初始化大小 private static final int DEFAULT_CAPACITY = 10; // 初始化一个空数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 底层存放数据的数组 transient Object[] e
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是一个非常重要的集合框架，用于动态数组的实现，其功能类似于数组，但可以在运行时动态调整大小。它是一个非线程...
ArrayList了解常规源码过程
Mac_niker的博客
03-24 147
为了读者的阅读，尽量避免长语句！ 根据以上图：得出ArrayList 实现List、RandomAccess、Cloneable、Serializable接口。 序列化Serializable是一个"标识性"的接口，即支持“序列化与反序列化”。 案例： 解读：本次创建类有 Person、实现有参构造、toString方法 解读： 1、SerializableDemo 为测试类，测试...
Java集合系列——ArrayList源码解读
Kingfar Ou
04-14 911
都2019年了还来谈ArrayList，不知道是不是太老套了，但是从另一个角度来想，Java集合本就是一个老少咸宜的话题，那就先从最简单的ArrayList开始谈吧。 概述 简单说下ArrayList的特点： ArrayList使用可变长数组来实现List接口的功能。 实现了所有列表有关的操作，允许添加所有类型的元素，连null都可以添加。 该类和Vector类相似，但是该类是线程不安全，Vec...
ArrayList的创建源码
Sun_hxx的博客
03-18 247
ArrayList的创建 public class ListTest { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); } } 点进去看一下构造方法 /** * Constructs an empty list with an initial capacity of ten. */ public
Java容器类源码-ArrayList的最全的源码分析
热门推荐
RyanLee的专栏
07-27 5万+
本文是针对Java 1.8的源代码进行解析的，可能会和其他版本有所出入。 笔者技术真的是一般般，写这个为了加深理解的同时给害怕看源代码的朋友一点鼓励，所以笔者在写的过程中有查阅很多资料来努力减少错误，但是如有错漏之处，希望大神们指出，我会第一时间修改，以免误人子弟，也希望和笔者一样基础不够好的朋友不要畏惧看源码，源码看起来并不会很难，而且多看源代码会对Java更深刻的理解。
java8 LinkedList源码分析
做一个会思考的技术人
03-13 185
LinkedList特点： 数据结构用双向链表实现，增删元素性能较好。 实现了所有List的接口。 可以插入null元素。 不是线程安全的。 类定义 继承AbstractSequentialList实现了List,Deque,Cloneable,Serializable接口。 public class LinkedList<E> exte...
数组 - 稀疏数组
kevin的博客
07-03 2万+
一，稀疏数组 1.定义 稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组 形如： 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
桶排序和计数排序
kevin的博客
04-17 5315
一，桶排序 1.算法原理 1.桶排序核心思想就是将要排序的数据分到几个有序的桶里，每个通在分别进行排序，每个桶排序完成后再把每个桶里的数据按照顺序依次取出，组成新的序列，该序列就是排好序的序列。类似归并排序中中的分治思想。 2.算法分析 时间复杂度接近O(N)，所以说桶排序是线性时间排序 空间复杂度：桶排序中，需要创建M个桶的额外空间，以及N个元素的额外空间，所以桶排序的空间复杂度为 O...
左式堆，斜堆及其合并操作
kevin的博客
04-05 3487
左式堆是堆的一种，但是左式堆是建立在一个具有堆序性的二叉树上而不是二叉堆 左式堆和二叉堆的共同点： 左式堆具有和二叉堆一样的堆序性 左式堆具有和二叉堆一样的结构性 左式堆和二叉堆的不同点： 左式堆虽然和二叉堆都是二叉树，但是左式堆和二叉堆不同的是，二叉堆接近完全完全二叉树，左式堆是不理想平衡的，更加直接的说，左式堆是趋向于非常不平衡的。 左式堆的一些概念 零路经长（NPL） 左式堆的零...
最大堆和最小堆
kevin的博客
08-20 3405
堆的特性 必须是完全二叉树 用数组实现 任一结点的值是其子树所有结点的最大值或最小值 最大值时，称为“最大堆”，也称大顶堆； 最小值时，称为“最小堆”，也称小顶堆。 最大堆: 最小堆： 对于堆（Heap）这种数据结构，从根节点到任意结点路径上所有的结点都是有序的 堆的实现 在堆中，一般将数组第一个元素赋值为null，不用数组第一位，所以 根节点：n 左子树则为...
归并排序和快速排序
kevin的博客
04-16 3405
一，归并排序 归并排序算法实现 算法思路： 如果要排序一个数组，我们先从数组中间把数组分成左数组和右数组两部分，分别对左右数组进行排序，然后将排序好的数组合并成结果数组，排序就完成了，最后只需将结果数组复制回原数组即可。 核心思想 ----- 分治思想 分治也即是分而治之，将一个大问题分解为小的子问题来解决。分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧。 归并...
深度解析Java ArrayList源码
以下是对ArrayList源码中关键部分的分析： 1. **数据结构**： ArrayList底层使用一个Object类型的数组`elementData`来存储元素。当数组满时，会通过扩容机制自动创建一个新的更大的数组并将原有元素复制过去。 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值