JDK1.8源码学习-ArrayList

Posted liudblog

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JDK1.8源码学习-ArrayList相关的知识,希望对你有一定的参考价值。

  JDK1.8源码学习-ArrayList

目录

一、ArrayList简介

为了弥补普通数组无法自动扩容的不足,Java提供了集合类,其中ArrayList对数组进行了封装,使其可以自动的扩容或缩小长度,相当于动态数组。

ArrayList封装了一个动态的可以重新分配的Object[]数组,其中每一个类的对象都有一个capacity属性,表示了它们所封装的Object[]数组的长度,当向ArrayList中添加元素的时候,该属性会自动的添加。如果想要添加大量元素的时候,可以使用ensureCapacity方法一次性增加capacity,减少数组的重新分配次数,提高效率。

二、ArrayList工作原理和数据结构

ArrayList 是基于数组来实现的

对于数组,这里就不进行过多叙述了。 想要说明的是ArrayList集合中底层数组元素的类型为Objec类型,即可以存放所有类型的数据。我们对ArrayList类的实例的操作,也都是基于数组的。

三、ArrayList源码分析

3.1、继承关系分析

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

ArrayList继承自AbstractList,实现了List、RandomAccess、Cloneable、Serializable接口,其中List中定义了一些基本的增删查改的功能,实现RandomAccess接口则具有随机读写的功能,实现了Cloneable接口,可以被克隆,实现了Serializable可以使ArrayList实现序列化。

3.2、成员变量分析

  //定义的序列化id,主要是为了标识不同版本的兼容性      
  private static final long serialVersionUID = 8683452581122892189L;  
  //默认的数组存储容量为 10  
  private static final int DEFAULT_CAPACITY = 10;  
  //当指定数组的容量为0的时候使用这个变量赋值,空对象数组  
  private static final Object[] EMPTY_ELEMENTDATA = {};  
  //默认的实例化的时候使用此变量赋值,空对象数组  
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  
  //真正存放数据的对象数组,并不被序列化 (前面加有transient关键字) 
  transient Object[] elementData;  
  //数组中的真实元素个数它小于或等于elementData.length  
  private int size;  
  //数组中最大存放元素的个数   
  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  

3.3、构造函数分析

3.3.1无参构造函数

ArrayList无参构造函数,默认初始化容量是10。

 /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  //默认值:10 
    }

在这里注释上说明构造一个容量为10的空的list,但是并没有看到数组的容量变为10,而是一个空的数组,实际上当有元素被加入(add方法)的时候,才会被初始化为10的数组。

3.3.2传入初始化容量构造函数

 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大小的数组。

3.3.3传入初始化元素的构造函数

 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            //判断引用的数组类型,并将引用转换成Object数组引用
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //替换为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

传入一个集合类(Collection的子类即可),转为list。

总结:可以看出ArrayList的内部存储结构就是一个Object类型的数组,因此它可以放任意类型的元素。在构造ArrayList的时候,如果传入初始大小,那么它将新建一个指定容量的Object数组,如果不设置初始大小,那么它将不会分配内存空间而是使用对象数组,在实际要放入元素的时候再进行内存分配。

3.4、add()方法分析

ArrayList中提供了四种方式的添加:1.直接添加;2.指定位置添加;3.添加全部;4.在指定位置添加全部。

1.直接添加

public boolean add(E e) {
  //添加前先检查是否需要拓展数组, 此时数组长度最小为size+1
  ensureCapacityInternal(size + 1);
  //将元素添加到数组末尾
  elementData[size++] = e;
  return true;
}

add(E e)调用涉及的方法:

1.private void ensureCapacityInternal(int minCapacity) {
     //判断数组是不是一个长度为0的空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //如果是的话则给容量赋值为默认的容量大小10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

2. private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //判断当前容量是否大于数组当前的长度
        if (minCapacity - elementData.length > 0)
            //如果数组容量过小则进行扩容
            grow(minCapacity);
    }

3.private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //扩容的长度是增加了原来数组的一半大小
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //判断是否达到了数组扩容的上限
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //把旧数组里面的数据拷贝到新数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

4.private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        //如果minCapacity还大于MAX_ARRAY_SIZE,那么就将Integer.MAX_VALUE返回,反之将MAX_ARRAY_SIZE返回。
        //因为maxCapacity是三倍的minCapacity,可能扩充的太大了,就用minCapacity来判断了。
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

2.指定位置添加

public void add(int index, E element) {
  //插入位置范围检查
  rangeCheckForAdd(index);
  //检查是否需要扩容
  ensureCapacityInternal(size + 1);
  //挪动插入位置后面的元素(将elementData中的元素从index开始,拷贝到index+1的位置,拷贝size-index个元素)
  System.arraycopy(elementData, index, elementData, index + 1, size - index);
  //在要插入的位置赋上新值
  elementData[index] = element;
  size++;
}

在指定位置进行添加,必然会影响到该位置的元素以及后续元素,因为是数组结构,所以只能进行元素的后移了,同时要首先检查入参的元素的位置(index)是否在范围内。

其中System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)方法中的参数的含义:src(原数组)、srcPos(从原数组的起始位置开始)、dest(目标数组)、destPos(目标数组的起始位置)、length(要copy的数组的长度)

3.添加一个集合中的全部元素

 public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        //检查是否需要扩容
        ensureCapacityInternal(size + numNew);
        //进行元素拷贝
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

4.在指定位置上添加一个集合中的全部元素

 public boolean addAll(int index, Collection<? extends E> c) {
        //插入位置范围检查
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        //检查是否需要扩容
        ensureCapacityInternal(size + numNew);
        //复制元素的个数
        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                    numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

3.5、set()方法分析

修改的方法比较简单,就是给数组的下标重新赋值。

public E set(int index, E element) {
  //index不能大于size
  rangeCheck(index);
  E oldValue = elementData(index);
  //替换成新元素
  elementData[index] = element;
  return oldValue;
}

确保set的位置(index)小于当前数组的长度(size)并且大于0,获取指定位置(index)元素,然后放到oldValue中存放,将需要设置的元素放到指定位置(index)上。

3.6、remove()方法分析

1. E remove(int index):根据下标进行删除

public E remove(int index) {
   // 检查下标是否越界
    rangeCheck(index); 

    modCount++;
    E oldValue = elementData(index);

    //最后 -1 是为了数组下标不越界
    int numMoved = size - index - 1; 
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; //置空引用,让GC进行回收

    return oldValue;
}

2.boolean remove(Object o):根据传入对象进行删除

// 删除成功返回true, 失败false
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;
}

// 快速删除指定下标的元素, 无越界检查
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; //置空引用,让GC进行回收
}

3. boolean removeAll(Collection<?> c):根据传入集合进行删除

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++)
            // 如果complement为false, 则c集合包含本集合中的元素, 则不进行操作, 这就是保留不属于c集合中的所有元素. 
            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;
}

如果传入的集合c中包含本集合中的元素,则对元素进行处理,把匹配的元素(c.contains(elementData[r])==complement)进行保留,不需要保留的下标置为null,其中利用complement属性,来决定含有的元素是删除还是保留。

3.7、get()方法分析

  public E get(int index) {  
        //检查是否越界  
        rangeCheck(index);  
        //返回指定位置上的元素  
        return elementData(index);  
    }  

四、ArrayList总结

1、ArrayList底层实现是基于数组的,因此对指定下标的查找和修改比较快,但是删除和插入操作比较慢。

2、构造ArrayList的时候尽量指定容量,减少扩容所带来的数组复制操作,如果不知道大小可以采用默认值10。

3、每次添加元素之前会检查是否需要扩容,每次扩容都是增加原有容量的一半。

4、ArrayList中的所有的方法都没有进行同步,因此它不是线程安全的。

5、在查找给定元素索引值等方法中,源码都将该元素的值分为null和不为null两种情况进行处理,ArrayList中允许元素为null。

 

 

 

以上是关于JDK1.8源码学习-ArrayList的主要内容,如果未能解决你的问题,请参考以下文章

ArrayList源码阅读分析(JDK1.8)

深入ArrayList源码分析(JDK1.8)

JDK1.8 CopyOnWriteArrayList源码学习

日常学习随笔-自定义了一个MyArrayListDefin集合(数组扩容+迭代器+JDK1.8新方法+详细说明)

ArrayList源码分析(JDK1.8)

JDK1.8中ArrayList的实现原理及源码分析