• 网站首页
  • 微服务
  • 设计模式
  • 并发编程
  • 源码分析
  • 中间件
  • 数据库
  • 文献
  • 工具
  • 其他
  • Java集合源码分析之ArrayList,你知道有多少?

    发布时间: 2019-12-23 15:48首页:架构技术精选 > 源码分析 > 阅读()

    前言:

    既然是看源码那我们要怎么看一个类的源码呢?这里我推荐的方法是:

    1)看继承结构

    看这个类的层次结构,处于一个什么位置,可以在自己心里有个大概的了解。

    2)看构造方法

    在构造方法中,看做了哪些事情,跟踪方法中里面的方法。

    3)看常用的方法

    跟构造方法一样,这个方法实现功能是如何实现的

    注:既然是源码,为什么要这样设计类,有这样的继承关系。这就要说到设计模式的问题了。所以我们要了解常用的设计模式,才能更深刻的去理解这个类。

    一:ArrayList简介

    1.1、ArrayList概述

    1. ArrayList是可以动态增长和缩减的索引序列,它基于数组实现的List类。
    2. 该类封装了一个动态再分配的Object【】数组,每一个类对象都有一个capacity属性,表示他们所封装的Object【】数组长度,当向ArrayList中添加元素时,该属性值会自动增加。如果想在ArrayList中添加大量元素,可使用ensureCapacity方法一次性添加capacity,可以减少增加重分配的次数,提高性能。
    3. ArrayList的用法和Vector向类似,但是Vector是一个较老的集合,具有很多缺点,不建议使用。另外,ArrayList和Vector的区别是:ArrayList是线程不安全的,当多条线程访问同一个ArrayList集合时,程序需要手动保证该集合的同步性,而Vector则是线程安全的。

    ArrayList的数据结构

    分析一个类的时候,数据结构往往是它的灵魂所在,理解底层的数据结构其实就理解了该类的实现思路,具体的实现细节再具体分析。

    ArrayList的数据结构是:

        

    说明:底层的数据结构就是数组,数组元素类型为Object类型,即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。

    二、ArrayList源码分析

    2.1、继承结构和层次关系

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

    分析:

    为什么要先继承AbstractList,而让AbstractList先实现List<E>?而不是让ArrayList直接实现List<E>?

    这里是有一个思想,接口中全都是抽象的方法,而抽象类中可以有抽象方法,还可以有具体的实现方法,正是利用了这一点,让AbstractList是实现接口中一些通用的方法,而具体的类,

    如ArrayList就继承这个AbstractList类,拿到一些通用的方法,然后自己在实现一些自己特有的方法,这样一来,让代码更简洁,就继承结构最底层的类中通用的方法都抽取出来,

    先一起实现了,减少重复代码。所以一般看到一个类上面还有一个抽象类。   

    2.2、类中的属性

    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        //版本号
        private static final long serialVersionUID = 8683452581122892189L;
        //缺省容量
        private static final int DEFAULT_CAPACITY = 10;
        //空对象数组
        private static final Object[] EMPTY_ELEMENTDATA = {};
        //缺省空对象数组
        private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
        //元素数组
        transient Object[] elementData; // non-private to simplify nested class access
        //实际元素大小,默认为0
        private int size;
        //最大数组容量
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    2.3、构造方法

    ArrayList有三个构造方法:

    1)无参构造方法  

    /**
     * 默认会给10的大小,所以一开始arrayList的容量就是10
     */
    public ArrayList() {
        //是个空的Object[],将elementData初始化,elementData也是个Object[]类型。空的object[]会默认赋值为10,后面会提到什么时候赋值
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    备注:

    transient Object[] elementData;
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     2)有参构造函数一

    public ArrayList(Collection<? extends E> c) {
        //转换为数组
        elementData = c.toArray();
        //判断数组中的数据个数
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //每个集合的toArray()的实现方法不一样,所以需要判断一下,如果不是Object[].class类型,那么就要使用ArrayList方法去改造下。
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    总结:arrayList的构造方法就做一件事情,就是初始化一下储存数据的容器,其实本质上就是一个数组,在其中就叫elementData。

    2.4、核心方法

    2.4.1、add()方法(有四个)

    1)boolean add(E);//默认直接在末尾添加元素

    //添加一个特定的元素到list末尾
    public boolean add(E e) {
        //确定内部容量是否够了,size是数组中数据的个数,因为要添加一个元素,所以size+1,先判断size+1这个个数在数组中是否放的下,就在这个方法中去判断是否数组.length是否够用了。
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //在数据中正确的位置放上元素e,并且size++
        elementData[size++] = e;
        return true;
    }

    分析:ensureCapacityInternal(xxx); 确定内部容量的方法   

    private void ensureCapacityInternal(int minCapacity) {
        //先判断初始化的elementData是否为空数组,也就是没有长度
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //因为如果是空的化,minCapacity =size+1;其实就是等于1,空的数组没有长度就存不了了,所以就将minCapacity变成10,也就是默认大小,但是在这里,还没有真正初始化这个elementData的大小
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //确认实际容量,上面只是将minCapacity =10,这个方法就是真正的判断elementData是否够用
        ensureExplicitCapacity(minCapacity);
    }

    ensureExplicitCapacity(xxx);

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //判断minCapacity 如果大于了实际elementData的长度,那么就说明elementData数组的长度不够用,不够用那么就要增加elementData的length。
        //1、minCapacity=size+1=1——>minCapacity=10,elementData.length =0
        //2、minCapacity=size+1=11,elementData.length=10,结果>0就要去扩容,这里举个例子
        if (minCapacity - elementData.length > 0)
            //自动扩展大小
            grow(minCapacity);
    }

    grow(xxx); arrayList核心的方法,能扩展数组大小的真正秘密。

    private void grow(int minCapacity) {
        // 将扩容前的elementData大小给oldCapacity
        int oldCapacity = elementData.length;
        //newCapacity =(1.5*oldCapacity)
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //newCapacity =0,minCapacity =10
        if (newCapacity - minCapacity < 0)
            //newCapacity =10
            newCapacity = minCapacity;
         //如果newCapacity超过了最大容量限制,就调用hugeCapacity,也就是将给的最大值给newCapacity
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 新的容量大小已经确定好了,就copy数组,改变容量大小了
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    hugeCapacity();  

    //用来赋最大值
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
      //两层防护
        return (minCapacity > MAX_ARRAY_SIZE) ?
            //Integer.MAX_VALUE:2147483647
            Integer.MAX_VALUE :
            //MAX_ARRAY_SIZE=2147483639
            MAX_ARRAY_SIZE;
    }

    2)void add(int,E);在特定位置添加元素,也就是插入元素

    public void add(int index, E element) {
        //检测index,也就是插入的位置是否合理
        rangeCheckForAdd(index);
        //分析过了
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这个方法就是用在插入元素之后,要将index之后的元素都往后移动一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //在目标位置上存存放元素
        elementData[index] = element;
        //size+1
        size++;
    }

    分析:rangeCheckForAdd(index)  

    private void rangeCheckForAdd(int index) {
        //插入的位置肯定不能大于size和小于0
        if (index > size || index < 0)
            //如果是,则数组越界异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    System.arraycopy(...):就是将elementData在插入位置后的所有元素往后面移一位。

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
    src:源对象
    srcPos:源对象对象的起始位置
    dest:目标对象
    destPost:目标对象的起始位置
    length:从起始位置往后复制的长度。

    总结:    

    正常情况下会扩容1.5倍,特殊情况下(新扩展数组大小已经达到了最大值)则只取最大值。

    当我们调用add方法时,实际上的函数调用如下:

    说明:程序调用add,实际上还会进行一系列调用,可能会调用到grow,grow可能会调用hugeCapacity。

    举例说明一: 

    ArrayList<Integer> lists = new ArrayList<Integer>();
    lists.add(8);

    说明:初始化lists大小为0,调用的ArrayList()型构造函数,那么在调用lists.add(8)方法时,会经过怎样的步骤呢?下图给出了该程序执行过程和最初与最后的elementData的大小。

    说明:我们可以看到,在add方法之前开始elementData = {};调用add方法时会继续调用,直至grow,最后elementData的大小变为10,之后再返回到add函数,把8放在elementData[0]中。

    举例说明二:  

    ArrayList<Integer> lists = new ArrayList<Integer>(6);
    lists.add(8);

    说明:调用的ArrayList(int)型构造函数,那么elementData被初始化为大小为6的Object数组,在调用add(8)方法时,具体的步骤如下:

    说明:我们可以知道,在调用add方法之前,elementData的大小已经为6,之后再进行传递,不会进行扩容处理。

    2.4.2、删除方法

    其实这几个删除方法都是类似的。我们选择几个讲,其中fastRemove(int)方法是private的,是提供给remove(Object)这个方法用的。

    1)remove(int):通过删除指定位置上的元素

    public E remove(int index) {
        //检测index的合理性
        rangeCheck(index);
        //这个作用很多,比如检测快速失败的一种标志
        modCount++;
        //通过索引直接找到该元素
        E oldValue = elementData(index);
        //计算要移动的位数
        int numMoved = size - index - 1;
        if (numMoved > 0)
            //移动元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将--size上的位置赋值为null,让gc(垃圾回收机制)更快的回收它
        elementData[--size] = null; // clear to let GC do its work
        //返回删除的元素
        return oldValue;
    }

    2)remove(Object):这个方法可以看出来,arrayList是可以存放null值得。

    //通过元素来删除该元素,就依次遍历,就将该元素的索引传给fastRemove(index),使用这个方法来删除该元素
    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;
    }
    //和remove方法实现差不多
    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
    }

    3)clear():将elementData中每个元素都赋值为null,等待垃圾回收将这个给回收掉,所以叫clear

    /**
     * Removes all of the elements from this list.  The list will
     * be empty after this call returns.
     */
    public void clear() {
        modCount++;
        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }

    4)removeAll(collection c):

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

    5)batchRemove(xx,xx):用于两个方法,一个removeAll():它只清楚指定集合中的元素,retainAll()用来测试两个集合是否有交集。 

    private boolean batchRemove(Collection<?> c, boolean complement) {
        //将原集合记为A
        final Object[] elementData = this.elementData;
        //r用来控制循环,w是记录有多少个交集
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                //参数中的集合c一次检测集合A中的元素是否有
                if (c.contains(elementData[r]) == complement)
                    //有就给集合A
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            //如果contains方法使用过程报异常
            if (r != size) {
                //将剩下的元素都赋值给集合A
                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;
    }

    总结::remove函数用户移除指定下标的元素,此时会把指定下标到数组末尾的元素向前移动一个单位,并且会把数组最后一个元素设置为null,

    2.4.3、set()方法

    public E set(int index, E element) {
        //检测索引是否合法
        rangeCheck(index);
        //旧值
        E oldValue = elementData(index);
        //赋新值
        elementData[index] = element;
        //返回旧值
        return oldValue;
    }

    说明:设定指定下标索引的元素值

    2.4.4、indexOf()方法

    //从首开始查找数组中是否存在指定元素
    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++)
                if (o.equals(elementData[i]))
                    return i;
        }
        //没有找到返回空
        return -1;
    }

    说明:从头开始查找与指定元素相等的元素,注意,是可以查找null元素的,意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf,表示从尾部开始查找。

    2.4.5、get()方法

    public E get(int index) {
        //检测索引合法性
        rangeCheck(index);
    
        return elementData(index);
    }

    说明:get函数会检查索引值是否合法(只检查是否大于size,而没有检查是否小于0),值得注意的是,在get函数中存在element函数,element函数用于返回具体的元素,具体函数如下:

    E elementData(int index) {
        return (E) elementData[index];
    }

    说明:返回的值都经过了向下转型(Object -> E),这些是对我们应用程序屏蔽的小细节。

    三、总结 

    1、arrayList是可以存放null。

    2、arrayList本质就是一个elementData数组。

    3、arrayList区别于数组的地方在于能够自动扩展大小,其中关键方法就是grow()方法

    4、arrayList中的removeAll(Collection c)和clear()的区别就是removeAll可以删除批量指定元素,而clear是全是删除集合中的元素。

    5、arrayList由于本质是数组,所以它在暑假查询方面会很快,而在插入删除这些方面,性能下降很多,要移动很多数据才能达到应有的效果。

    6、arrayList实现了RandomAccess,所以在遍历它的时候推荐使用for循环

    补充:RandomAccess接口:这个是一个标记性接口,通过查看api文档,它的作用就是用来快速随机存取,有关效率的问题,在实现了该接口的话,那么使用普通的for循环来遍历,性能更高,例如arrayList。

    原文链接:https://www.cnblogs.com/zhangyinhua/

    特别声明:文章内容仅供参考,不造成任何投资建议。投资者据此操作,风险自担。

    网站首页 - 微服务 - 设计模式 - 并发编程 - 源码分析 - 中间件 - 数据库 - 文献 - 工具 - 其他

    本站不良内容举报联系客服QQ:483966038 官方微信:MYKT-xiaowei 服务热线:

    未经本站书面特别授权,请勿转载或建立镜像

    Copyright © 2016-2020 架构技术精选 版权所有 XMl地图