Java集合源码分析之ArrayList

时间  2019-11-22
标签 java 集合 源码 分析 arraylist 栏目 Java 繁體版
原文   原文链接

前言：

既然是看源码那咱们要怎么看一个类的源码呢？这里我推荐的方法是：java

1）看继承结构设计模式

看这个类的层次结构，处于一个什么位置，能够在本身内心有个大概的了解。api

2）看构造方法数组

在构造方法中，看作了哪些事情，跟踪方法中里面的方法。安全

3）看经常使用的方法数据结构

跟构造方法同样，这个方法实现功能是如何实现的dom

注：既然是源码，为何要这样设计类，有这样的继承关系。这就要说到设计模式的问题了。因此咱们要了解经常使用的设计模式，才能更深入的去理解这个类。函数

一：ArrayList简介

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类的实例的全部的操做底层都是基于数组的。

2、ArrayList源码分析

2.一、继承结构和层次关系

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.二、类中的属性

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.三、构造方法

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.四、核心方法

2.4.一、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。     //一、minCapacity=size+1=1——>minCapacity=10,elementData.length =0     //二、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.二、删除方法

其实这几个删除方法都是相似的。咱们选择几个讲，其中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.三、set()方法

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

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

2.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.五、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），这些是对咱们应用程序屏蔽的小细节。

3、总结　

一、arrayList是能够存放null。

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

三、arrayList区别于数组的地方在于可以自动扩展大小，其中关键方法就是grow（）方法

四、arrayList中的removeAll（Collection c）和clear（）的区别就是removeAll能够删除批量指定元素，而clear是全是删除集合中的元素。

五、arrayList因为本质是数组，因此它在暑假查询方面会很快，而在插入删除这些方面，性能降低不少，要移动不少数据才能达到应有的效果。

六、arrayList实现了RandomAccess,因此在遍历它的时候推荐使用for循环

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

原文连接：https://www.cnblogs.com/zhangyinhua/

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程