ArrayList底层源码分析

最新推荐文章于 2024-05-03 12:16:16 发布

有温度的代码

最新推荐文章于 2024-05-03 12:16:16 发布

阅读量1.7k

点赞数

文章标签： java 前端开发语言

本文链接：https://blog.csdn.net/qq_42600094/article/details/130501673

版权

前言

今天就来介绍一下ArrayList，说到ArrayList，很多人都知道它的底层是使用数组实现的，线程不安全的，说到它的特点，都会说查找快，增删慢，因为面试题大家都是这么背过来的。今天就来说说它的底层源码吧。

ArrayList更准确的说是动态数组去实现的，这里使用动态两字，是为了能够充分体现它的特点。

再者就是ArrayList不是线程安全的，所以效率比较高，但是否这个是绝对的呢？答案是否定的。

ArrayList的实现和继承的类

下图所示:
在这里插入图片描述

ArrayList底层源码

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

(1) ArrayList继承AbstractList抽象类，实现了RandomAccess、Cloneable、Serializable接口，RandomAccess是其拥有快速访问的能力。
(2) Cloneable其实就是一个标记接口，只有实现这个接口后，然后在类中重写Object中的clone方法，然后通过类调用clone方法才能克隆成功，如果不实现这个接口，则会抛出CloneNotSupportedException(克隆不被支持)异常。
(3) Serializable是序列化接口，支持序列化和反序列化。

(4)private static final int DEFAULT_CAPACITY = 10; 是ArrayList默认的初始化集合的大小
(5)private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 是一个空对象数组，用于空实例的共享空数组实例。

(6)private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 是使用默认构造函数创建集合的时候使用该对象

(7)transient Object[] elementData. elementData用于存放当前数据的数组对象。
(8)size是集合的大小。
(9)当集合中的元素超出数组规定的长度时，数组就会进行扩容操作，扩容操作就是ArrayList存储操作缓慢的原因，尤其是当数据量较大的时候，每次扩容消耗的时间会越来越多。

ArrayList的构造方法源码

ArrayList(int 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);
        }
    }

(1) 该构造函数很简单，直接判断传进来的数值大小，要是大于零，直接初始一个该长度的数组对象，并赋值给elementData，要是等于零，将空数组对象EMPTY_ELEMENTDATA赋给elementData，否则，直接抛出异常。
(2) 该构造函数一般使用在要初始化一个比较大数据量的的集合的时候使用。

ArrayList()

  public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

(1) 将DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组对象赋给elementData

ArrayList(Collection<? extends E> c)

public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

这里主要做了两件事:
(1) 先将集合c转化为数组，然后赋值给elementData数组对象。
(2) 然后判断size和是否相等并且不等于0，是则执行数据的赋值并重新赋值给数组对象elementData，否则直接将空数组对象赋值给elementData。

ArrayList的方法源码分析

add()方法顺序添加单个元素

   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

(1) 执行ensureCapacityInternal方法，判断原有的数组对象是否需要扩容。
(2) 将e对象添加到elementData数组对象中。

接下来我们来看看ensureCapacityInternal方法的源码。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

在ensureCapacityInternal 中调用了ensureExplicitCapacity 方法和 calculateCapacity 方法，我们来看下calculateCapacity 方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

(1) 这里的任务主要是计算容量的大小，先判断elementData数组对象是否有初始化大小，若没有就取DEFAULT_CAPACITY或 minCapacit中的较大者为容量的大小，若已经初始化了就minCapacity为容量大小。

接着来看看ensureExplicitCapacity的源码：

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

执行modCount自增，modCount为当前列表结构被修改次数。
(2) 判断minCapacity要是大于elementData.length就执行扩容，否则，直接退出此方法，进行添加元素的操作。

接着我们来看看grow方法的源码：

   private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

(1) 这里先拿到原来数据elementData的长度赋给一个变量oldCapacity，然后将原来的长度扩大1.5倍并付给oldCapacity。
(2) 判断minCapacity 是否大于newCapacity，成立则将minCapacity赋给newCapacity，为什么要这么做呢？因为从前的一层层的方法进行解析之后来看，minCapacity是允许扩容后的最小长度，也就是实际存有数据的最小长度，要是你扩容后的长度还比minCapacity要小，那么只能将minCapacity作为容器的长度。
(3) 然后判断容器新长度newCapacity是否大于容器所允许的最大长度MAX_ARRAY_SIZE，成立则将扩容长度设置为最大可用长度。
(4) 拷贝，扩容，构建一个新的数组。

接着我们来看看grow方法调用的hugeCapacity的源码：

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

(1) 直接判断minCapacity是否小于零，成立抛出异常，然后比较容器所允许的最小长度值是否大于MAX_ARRAY_SIZE，成立则将Integer的最大值赋值给minCapacity作为容器的最大长度。

add(int index, E element)方法

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++;
    }

(1) 这里主要做三件事，第一件就是判断下标是否越界，如果是则抛出IndexOutOfBoundsException异常。
(2) 然后就是判断是否需要扩容，这个方法和上面的一样，已经说过了，就不再赘述了。
(3) 最后就是执行数组对象index后的对象后移一位，将元素添加到指定位置。

接下来我们来看看rangeCheckForAdd的源码

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

(1) 直接就是判断index > size或者index < 0条件，成立就直接抛出数组下标越界异常。

 public boolean addAll(Collection<? extends E> c) {
            return addAll(this.size, c);
        }

        public boolean addAll(int index, Collection<? extends E> c) {
            rangeCheckForAdd(index);
            int cSize = c.size();
            if (cSize==0)
                return false;

            checkForComodification();
            parent.addAll(parentOffset + index, c);
            this.modCount = parent.modCount;
            this.size += cSize;
            return true;
        }

(1) addAll(Collection c)方法里面直接调用addAll(this.size, c)，在addAll(this.size, c)里面第一件事就是判断是否下标越界。
(2) 然后判断c的大小是否大于0，如果等于0 返回 false。
(3) 检查修改的次数是否相等，若不相等直接则抛出ConcurrentModificationException（并发修改）异常，这个也就是当我们用迭代器循环list的时候，在其中用list的方法新增/删除元素，就会出现这个错误。
(4) 将元素插入到数组中，将修改次数赋值给 modCount，最后size大小加一
(5) 在进行 add 操作时先判断下标是否越界，是否需要扩容，如果需要扩容，就复制数组，默认扩容一半，如果扩容一半不够的话，就用目标的size作为扩容后的容量，然后设置对应的下标元素值。

get()方法

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

(1) 这个就很简单了直接就是先判断是否下标越界，越界就抛出异常，最后返回指定index位置的元素值。

set()方法

  public E set(int index, E e) {
            rangeCheck(index);
            checkForComodification();
            E oldValue = ArrayList.this.elementData(offset + index);
            ArrayList.this.elementData[offset + index] = e;
            return oldValue;
        }

(1) 先判断是否越界，然后取出原来index位置的值为oldValue，将新的值element设置到index位置，最后将旧的值oldValue返回。

remove()方法

 public E remove(int index) {
        rangeCheck(index);
        checkForComodification();
        E result = parent.remove(parentOffset + index);
        this.modCount = parent.modCount;
        this.size--;
        return result;
    }

(1) 判断是否越界，然后将修改次数modCount值加1，然后就是获得原来index位置的旧值。
(2) 然后是计算index位置后面有多少个元素，接着将index位置后的元素向前移动一位，最后将旧值返回。

remove(Object o)方法

 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;
    }

这个根据对象删除的方法比较简单，首先判断o对象是否为null对象，为null就遍历集合中的元素，是否存在null值，存在执行删除，删除指定对象的方法是fastRemove，原理就是计算index位置后的元素个数，然后将index后的元素都往前移动一位，最后将最后的一位赋值为null值。
(2) 若o对象是不为null对象的时候，执行的逻辑是一样的，那么为什么要分开写呢？很简单，因为它后面要调用o.equals(elementData[index]方法进行判断，要是为null，不就报空指针异常了。

手动缩容

// ArrayList.java

public void trimToSize() {
    // 增加修改次数
    modCount++;
    // 如果有多余的空间，则进行缩容
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA // 大小为 0 时，直接使用 EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size); // 大小大于 0 ，则创建大小为 size 的新数组，将原数组复制到其中。
    }
}

Iterator迭代器

 public Iterator<E> iterator() {
        return new Itr();
    }

  /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

(1) 迭代器中有几个属性比较重要，int cursor是下一个要返回的元素的索引， int lastRet = -1 是返回的最后一个元素的索引，默认为-1，就是没有的情况。
(2) hasNext方法判断是否存在下一个元素，通过判断以下一个下标是否为数组大小。
(3) next方法获取下一个元素，首先先调用checkForComodification方法检查修改的次数是否一致，然后定义下一个元素的下标，判断下标，如果下标大于ArrayList包含的元素个数，抛出 NoSuchElementException （没有这样的元素异常）异常，接着拿到ArrayList中的elementData数据对象，再次判断下标，如果此次判断不一致则说明数组被修改过，最后将cursor +1，指向下一个元素的下标，最后将lastRet定义为返回的元素的下标，然后返回下标对应的值。
(4) remove移除当前元素，首先判断最后一个元素的下标lastRet 是否小于0，成立则不存在该元素，抛出异常，然后又调用 checkForComodification，判断修改次数是否一致，接着调用ArrayList的remove方法，最后重新更新cursor 、 lastRet、expectedModCount的值。

总结
下面，我们来对 ArrayList 做一个简单的小结：
ArrayList 是基于 [] 数组实现的 List 实现类，支持在数组容量不够时，一般按照 1.5 倍自动扩容。同时，它支持手动扩容、手动缩容。
ArrayList 随机访问时间复杂度是 O(1) ，查找指定元素的平均时间复杂度是 O(n) 。
ArrayList 移除指定位置的元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n) 。最好时间复杂度发生在末尾移除的情况。因为移除头部或者中间的元素要位移
ArrayList 移除指定元素的时间复杂度是 O(n) 。
因为首先需要进行查询，然后在使用移除指定位置的元素同时需要位移，无论怎么计算，都需要 O(n) 的时间复杂度。
ArrayList 添加元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n) 。
最好时间复杂度发生在末尾添加的情况。

有温度的代码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ArrayList底层源码分析

下面，我们来对 ArrayList 做一个简单的小结：ArrayList 是基于 [] 数组实现的 List 实现类，支持在数组容量不够时，一般按照 1.5 倍自动扩容。同时，它支持手动扩容、手动缩容。ArrayList 随机访问时间复杂度是 O(1) ，查找指定元素的平均时间复杂度是 O(n)。ArrayList 移除指定位置的元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n)。最好时间复杂度发生在末尾移除的情况。因为移除头部或者中间的元素要位移。
复制链接

扫一扫