Java集合框架之ArrayList源码详解

最新推荐文章于 2021-02-19 14:59:36 发布

难搞哦！！

最新推荐文章于 2021-02-19 14:59:36 发布

阅读量289

点赞数 1

分类专栏： java学习文章标签： ArrayList源码详解 ArrayList方法源码详解 ArrayList Java

本文链接：https://blog.csdn.net/qq_37892957/article/details/81951953

版权

java学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

最近突然想对学过的知识进行总结概述，看过很多写Java集合框架的资料，现在自己打算根据自己的水平写一下ArrayList的源码详解，写得可能不是太好，望海涵。

3.传递一个Collection集合的构造器

4.clear清空ArrayList的元素

5.addAll方法

6.ArrayList中检查越界的方法

7.removeAll 批量删除元素操作

8.ArrayList中构建Interatory方法

（六）参考文献

参考文献：

（一）ArrayList概述

ArrayList底层是一个动态数组，可以根据插入值的长度大小进行扩容操作。ArrayList实现了RandomAccess接口实现此接口的作用是随机访问，实现了Cloneable接口作用是支持复制，同时也实现了Serialzable接口可以进行序列化和反序列化操作

（二）ArrayList细节讲解

ArrayList并不是一个线程安全的，所以我们一般建议在单线程环境下。其中ArrayList源码中有一个成员变量modCount是为了保证我们在使用迭代器的时候防止因为多线程环境下的插入删除引起的数据不一致的问题,各位有兴趣的可以去试试在循环的过程中对正在循环的ArrayList集合进行删除，你会发现结果会出乎各位的意料的。

（三）ArrayList源码中的成员变量

    //默认的容量
    private static final int DEFAULT_CAPACITY = 10;

    //一个空的元素集合
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //与EMPTYT——ELEMENTDATA做对比 当第一次插入元素时知道自己需要膨胀多少即扩容多大
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //ArrayList真实保存数据的数组  默认采用的是Object来保存值
    transient Object[] elementData; // non-private to simplify nested class access

    //ArrayList的大小
    private int size;

（四）ArrayList中的构造函数

1.带初始化容量参数的构造器

/**
     * 初始化容量构造器
     * 如果参数>0则直接new一个Object容量的数组
     * 如果参数==0 会将上诉的静态EMPTY_ELEMENTDATA属性赋值给elementData，不会产生新的元素数组
     * 如果小于0  则抛出一个非法容量的异常
     *
     * @param initialCapacity 容量大小
     */
    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);
        }
    }

2.无参构造器

    /**
     * 无参构造求 默认将DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空数组赋值给elementData
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

3.传递一个Collection集合的构造器

    /**
     * 传递一个集合给ArrayList
     *
     * @param c
     */
    public ArrayList(Collection<? extends E> c) {
        //将集合转换成数组赋值给elementData
        elementData = c.toArray();
        //如果elementData的长度不为0   说明集合中是有元素的
        if ((size = elementData.length) != 0) {
            //c.toArray可能会造成一点误差会不返回Object的数组 所以我们需要进行判断一下防止这种错误的发生
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //为0依旧还是一个静态的空数组引用
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

（五）ArrayList中重要的方法详解

1、容量方法

    //供用户调用的方法  用户可以设置容量大小
    public void ensureCapacity(int minCapacity) {
        //最小扩容容量 判断是不是空的ArrayList 如果是的话最小扩容为10 否则扩容为0
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                ? 0
                : DEFAULT_CAPACITY;
        //如果用户指定的最小容量>最小扩容容量 则以用户指定标准为标准
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    //私有方法 明确ArrayList的容量 提供给本类使用
    private void ensureCapacityInternal(int minCapacity) {
        // 若 elementData == {}，则取 minCapacity 为 默认容量和参数 minCapacity 之间的最大值
        // 注：ensureCapacity() 是提供给用户使用的方法，在 ArrayList 的实现中并没有使用
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

ensureCapacityInternal方法的是ArrayList中私有的明确容量方法，改方法能够使得ArrayList的容量能够接近真实容量的大小，不至于浪费过大的空间。

例如：ArrayList list = new ArrayList<>()现在我们构造了一个ArrayList的集合，ArrayList在构建的时候如果是无参构造器默认采用的空间是10 如果我们向其中插入一个元素那真实的容量就是1 ，如果数据过于庞大则会导致资源的过度浪费，后面我们将ArrayList的扩容。

下面这个方式是ensureCapacityInternal方法里面调用的内部方法此方法是讲解如何内部优化的方法。

     /**
     * 私有方法：明确 ArrayList 的容量
     * - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
     *
     * @param minCapacity 指定的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        //如果最小的容量比elementData.length的容量大的话则扩容 防止代码溢出
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

如果最小的容量都比ArrayList的容量大的话那我们就需要对ArrayList进行扩容防止代码溢出。下面试是ArrayList中的扩容操作。


    /**
     * 数组缓冲区最大存储容量
     * - 一些 VM 会在一个数组中存储某些数据--->为什么要减去 8 的原因
     * - 尝试分配这个最大存储容量，可能会导致 OutOfMemoryError(当该值 > VM 的限制时)
     */
    /*为什么这里要减8呢？*/
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    /*
        使用方法 数组扩容 用来确保Arraylist至少要存储minCapacity个元素
        扩容计算公式 newCapacity = oldCapacity + (oldCapacity>>1) 扩容当前容量的1.5倍
    * */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果新的数组容量-最小数组容量<0 则说明最小的容量大于了新的容量则将新的容量等于最小容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新的容量 - 最大的容量的话 则进行大容量分配
        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);
    }

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

阅读的时候我们发现数据缓冲区的MAX_ARRAY_SIZE =Integer.MAX_VALUE-8这里我们为什么需要减8呢？

具体可以看下面这个链接：

https://stackoverflow.com/questions/35756277/why-the-maximum-array-size-of-arraylist-is-integer-max-value-8

2.add方法

根据上面我们明白了ArrayList的扩容原理接下来我们讲解ArrayList的常用具体方法实现原理

    /**
     * 向ArrayList中添加一个元素
     * @param e 元素
     * @return 返回添加是否成功
     */
    public boolean add(E e) {
        //明确Arraylistde容量  保存多少元素就存储多少元素 节省空间
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * 向目标索引位置插入值
     * @param index
     * @param element
     */
    public void add(int index, E element) {
        //检查索引越界
        rangeCheckForAdd(index);
        //明确ArrayList的容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //重点 第一个参数是复制的数组 ，第二个参数是要复制的数组是从哪里开始的，第三个是参数是复制到哪里
        //第四个参数是复制到的数组从第几个开始 最后一个是复制的长度
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        elementData[index] = element;
        size++;
    }

添加一个元素的时候我们ArrayList底层会代用自己定义的ensureCapacityInternal方法来明确我此时到底需要多少的真正容量，而不是进行一味的扩容操作浪费空间。

3.移除元素操作

    /**
     * 移除某个索引位置的元素
     * @param index
     * @return
     */
    public E remove(int index) {
        //检查索引越界
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
        //需要移动的距离 判断是否是最后一个元素
        //如果是最后一个元素就直接让最后一个元素的值为null
        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;
    }

/**
     * 移除元素 通过循环匹配来确定
     * @param o
     * @return
     */
    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;
    }

上述移除元素中，第二张代码图我们看见循环体中调用了一个fastRemove（index）的方法我们接着往源码下面走会发现：

     /**
     * 私有方法 跳过检查 执行快速删除
     * @param index
     */
    private void fastRemove(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
    }

改方法没有执行检查操作，而是快速删除，因为我们删除的元素是元素值而不是索引，我们没必要再去浪费时间去进行索引检查。