美文网首页
Java集合(容器)框架 01 - ArrayList源码分析

Java集合(容器)框架 01 - ArrayList源码分析

作者: L2先森 | 来源:发表于2019-04-07 07:56 被阅读0次

    说明: 源码分析基于 JDK1.8

    ArrayList简介

    ArrayList 是基于数组实现的,支持快速随机访问。RandomAccess 接口标识着该类支持快速随机访问。

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

    ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。

    ArrayList 实现了Cloneable接口,即覆盖了函数 clone(),能被克隆。

    ArrayList 实现Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。

    ArrayList 实现了RandomAccess接口,即提供了随机访问功能。可以通过元素的序号快速获取元素对象;这就是快速随机访问。

    Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList

    ArrayList一些重要的字段:

        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
        private int size;//底层数组中实际元素个数,区别于capacity
    

    非线程安全:

    ArrayList的实现是不同步的,如果多个线程同时访问ArrayList实例,并且至少有一个线程修改list的结构,那么它就必须在外部进行同步。如果没有这些对象, 这个list应该用Collections.synchronizedList()方法进行包装。 最好在list的创建时就完成包装,防止意外地非同步地访问list:

    List list = Collections.synchronizedList(new ArrayList(...));
    

    除了未实现同步之外,ArrayList大致相当于Vector。

    其中有一个重要的实例变量modCount,主要在多线程环境下进行安全检查,防止一个线程正在迭代遍历,另一个线程修改了这个列表的结构。如果在使用迭代器进行遍历ArrayList的时候modCount值改变,则会报ConcurrentModificationException异常。

    扩容

    当向容器中添加元素时,如果容量不足,容器会自动增大底层数组的大小。

    添加元素时使用ensureCapacityInternal()方法来保证容量足够,如果不够时,需要使用 grow() 方法进行扩容,新容量的大小为 oldCapacity + (oldCapacity >> 1),也就是旧容量的 1.5 倍。

    image

    核心扩容

        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
    //下面是ArrayList的扩容机制
    //ArrayList的扩容机制提高了性能,如果每次只扩充一个,
    //那么频繁的插入会导致频繁的拷贝,降低性能,而ArrayList的扩容机制避免了这种情况。
        /**
         * 如有必要,增加此ArrayList实例的容量,以确保它至少能容纳元素的数量
         * @param   minCapacity   所需的最小容量
         */
        public void ensureCapacity(int minCapacity) {
            int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                // any size if not default element table
                ? 0
                // larger than default for default empty table. It's already
                // supposed to be at default size.
                : DEFAULT_CAPACITY;
    
            if (minCapacity > minExpand) {
                ensureExplicitCapacity(minCapacity);
            }
        }
       //得到最小扩容量
        private void ensureCapacityInternal(int minCapacity) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                  // 获取默认的容量和传入参数的较大值
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
    
            ensureExplicitCapacity(minCapacity);
        }
      //判断是否需要扩容,上面两个方法都要调用
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
    
            // 如果说minCapacity也就是所需的最小容量大于保存ArrayList数据的数组的长度的话,就需要调用grow(minCapacity)方法扩容。
            //这个minCapacity到底为多少呢?举个例子在添加元素(add)方法中这个minCapacity的大小就为现在数组的长度加1
            if (minCapacity - elementData.length > 0)
                //调用grow方法进行扩容,调用此方法代表已经开始扩容了
                grow(minCapacity);
        }
        
         /**
         * ArrayList扩容的核心方法。
         */
        private void grow(int minCapacity) {
           //elementData为保存ArrayList数据的数组
           ///elementData.length求数组长度elementData.size是求数组中的元素个数
            // oldCapacity为旧容量,newCapacity为新容量
            int oldCapacity = elementData.length;
            //将oldCapacity 右移一位,其效果相当于oldCapacity /2,
            //我们知道位运算的速度远远快于整除运算,整句运算式的结果就是将新容量更新为旧容量的1.5倍,
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            //然后检查新容量是否大于最小需要容量,若还是小于最小需要容量,那么就把最小需要容量当作数组的新容量,
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            //再检查新容量是否超出了ArrayList所定义的最大容量,
            //若超出了,则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE,
            //如果minCapacity大于MAX_ARRAY_SIZE,则新容量则为Interger.MAX_VALUE,否则,新容量大小则为 MAX_ARRAY_SIZE。
            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);
        }
    

    扩容机制代码已经做了详细的解释。另外值得注意的是大家很容易忽略的一个运算符:移位运算符。移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。作用:对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源。比如这里:int newCapacity = oldCapacity + (oldCapacity >> 1); 右移一位相当于除2,右移n位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了1位所以相当于oldCapacity /2。

    删除操作

    需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上,该操作的时间复杂度为 O(N),可以看出 ArrayList 删除元素的代价是非常高的。

    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        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;
    }
    

    添加操作

    add()方法:

    public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
    }
    
    public void add(int index, E element) {
            rangeCheckForAdd(index);
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            elementData[index] = element;
            size++;
    }
    
    image

    直接在数组后面插入一个元素add(e)效率也很高,但是如果要按下标来插入元素,则需要调用System.arraycopy()方法来移动部分受影响的元素,这会导致性能低下,这也是使用数组实现的ArrayList的劣势。

    同理,remove()方法也会改变modCount的值,效率与按下标插入元素相似,在此不加赘述。

    addAll()方法:

    public boolean addAll(Collection<? extends E> c) {
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacityInternal(size + numNew);  // Increments modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
    }
    
    public boolean addAll(int index, Collection<? extends E> c) {
            rangeCheckForAdd(index);
    
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacityInternal(size + numNew);  // Increments modCount
    
            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;
    }
    

    addAll方法也分在末尾插入和在指定位置插入,先将入参中的集合c转换成数组,根据转换后数组的程度和ArrayList的size拓展容量,之后调用System.arraycopy()方法复制元素到相应位置,调整size。根据返回的内容分析,只要集合c的大小不为空,即转换后的数组长度不为0则返回true。

    addAll()方法的时间开销是跟添加元素的个数成正比的。

    System.arraycopy()和Arrays.copyOf()方法

    通过源码我们发现这两个实现数组复制的方法被广泛使用而且很多地方都特别巧妙。比如下面add(int index, E element)方法就很巧妙的用到了System.arraycopy()方法让数组自己复制自己实现让index开始之后的所有成员后移一个位置:

        /**
         * 在此列表中的指定位置插入指定的元素。 
         *先调用 rangeCheckForAdd 对index进行界限检查;然后调用 ensureCapacityInternal 方法保证capacity足够大;
         *再将从index开始之后的所有成员后移一个位置;将element插入index位置;最后size加1。
         */
        public void add(int index, E element) {
            rangeCheckForAdd(index);
    
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            //arraycopy()方法实现数组自己复制自己
            //elementData:源数组;index:源数组中的起始位置;elementData:目标数组;index + 1:目标数组中的起始位置; size - index:要复制的数组元素的数量;
            System.arraycopy(elementData, index, elementData, index + 1, size - index);
            elementData[index] = element;
            size++;
        }
    

    toArray()方法中用到了Arrays.copyOf()方法:

        /**
         *以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。 
         *返回的数组将是“安全的”,因为该列表不保留对它的引用。 (换句话说,这个方法必须分配一个新的数组)。
         *因此,调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
         */
        public Object[] toArray() {
        //elementData:要复制的数组;size:要复制的长度
            return Arrays.copyOf(elementData, size);
        }
    

    Arrays.copyOf()方法内部调用了System.arraycopy()方法:

    • System.arraycopy()方法是一个native方法,调用了系统的C/C++代码,在openJDK中可以看到其源码。比一般的复制方法的实现效率要高很多,很适合用来批量处理数组。需要目标数组,将原数组拷贝到你自己定义的数组里,而且可以选择拷贝的起点和长度以及放入新数组中的位置
    • Arrays.copyOf()该方法实际上是在其内部创建了一个类型为newType、长度为newLength的新数组,调用System.arraycopy()方法,将原来数组中的元素复制到新的数组中。有很多重载版本,但实现思路都是一样的,其泛型版本源码如下:
    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) {  
        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;  
    }  
    

    结尾

    ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动、代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。

    参考文献:

    相关文章

      网友评论

          本文标题:Java集合(容器)框架 01 - ArrayList源码分析

          本文链接:https://www.haomeiwen.com/subject/slsjiqtx.html