在？进来复习一下ArrayList

最新推荐文章于 2024-11-04 20:33:37 发布

Zoyp晨

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量168

点赞数 2

分类专栏： JDK 集合源码分析文章标签： java 数据结构 android 编程语言 android studio

本文链接：https://blog.csdn.net/qq_43747542/article/details/105945857

版权

JDK 集合源码分析专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java ArrayList 源码解析

ps：这篇文章是Java 集合框架源码分析系列的第一篇文章，从Java中最常用的集合类ArrayList开始。

ArrayList简介

以下源码来自jdk1.8

这是一个实现了List接口的底层通过数组实现的容量可变的集合
类中add方法的时间复杂度为O(n)，其他操作的时间复杂度大致与add方法的时间复杂度持平
创建ArrayList时，可以指定预期容量大小，也可以不指定，但如果知道预期存储元素的大小，创建ArrayList时指定大小可以减少动态扩容的消耗
ArrayList是线程不安全的集合，所以不要多线程环境下使用ArrayList，可以使用Collections工具类中的：mList = Collections.synchronizedList(mList);来将一个List转换成线程安全的集合
如果在操作ArrayList的迭代器或SubList（ArrayList的一个子类，代表ArrasyList的视图）的情况下，同时操作arrayList本类，则会抛出ConcurrentModificationException

下面贴一下ArrayList的官方文档：
IDEA是真的好用啊

ArrayList类的继承关系：

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

RandomAccess 空接口，代表这个类支持随机访问，并且当对ArrayList遍历时，通过索引访问的效率要比迭代器的效率高
Cloneable 支持实例克隆，这里实现的克隆是浅克隆
Serializable 支持序列化

ArrayList的构造函数

分析ArrayList的源码，让我们先从构造函数开始看起，这是一个使用一个类的起点：

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

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

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

成员变量：

 	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;

ArrayList(int initialCapacity)

这种构造函数指定了底层存储元素数组elementData的容量,通过这种方式不会使用EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA这两个成员变量数组，直接将elementDatanew出来，不过当容量为0时，element指向EMPTY_ELEMENTDATA 空数组

ArrayList()

将elementData指向默认数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA

ArrayList(Collection<? extends E> c)

将集合c中的元素转成数组然后让elementData指向这个数组

总的来说，三个构造函数都在初始化elementData这个ArrayList底层存储元素的数组

常用方法

add(E e)

容易想到的是，动态扩容机制一定是在add方法中直接或间接执行的，先看add方法的源码

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

将元素e存储在elementData数组内，ensureCapacityInternal这个方法翻译过来就是，确定内部容量

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

只有我们执行空参数构造函数，if条件才成立，返回DEFAULT_CAPACITY, minCapacity的较大值，然后充当ensureExplicitCapacity方法的参数，DEFAULT_CAPACITY常量的值指定为10

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

这里将modeCount++，这个成员变量的作用是为了防止迭代器或视图和arraylist同时进行增删，具体后面再说，先看完整流程，这个方法的最后调用了grow，grow方法是真正的数组扩容的方法。

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

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

通过Arrays.copyOf返回扩容后的数组然后将引用重新赋值给elementData

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

通过grow方法可以总结出ArrayList动态扩容的逻辑：

正常逻辑：
执行add方法是，如果当前元素的size + 1大于elementData数组的大小，那么就触发扩容机制，将当前数组大小扩大1一半，也就是：10.15.22.33,49…，数组的最大大小是Integer.MAX_VALUE,超出这个大小会抛出：OutOfMemoryError异常：

	private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        ...
    }

第一次add时
如果构造函数时没有指定容量，那么当第一次执行add方法时，会将数组大小指定为DEFAULT_CAPACITY：10。

set(int index, E element)

就是在检查index是否合法后，修改element数组对应idex的值。

	public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

get()

返回数组中的值

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

        return elementData(index);
    }

remove(int index)

移除此列表中指定位置的元素。,被删除元素的所有后续元素向左移一位。容易想到的时，使用ArrayList尽量不要在中间增加或删除元素，尤其是当size很大时，这样会非常消耗资源。这里又看到了modeCount++这个操作。

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

这样增删改查方法就分析完毕，其他的一些方法都是对elementData数组进行的操作，就不展开一一分析了。

modCount

上面我们看到在add和remove方法中会让modCount++，那这个变量到底有什么用呢？
它的作用是为了阻止arraylist和它的迭代器或subList同时修改elementData这个数组，否则会有并发问题。ArrayList是线程不安全集合。先看一下这一段代码：

	public static void main(String[] args) throws InterruptedException {
        ArrayList<String> arrayList = new ArrayList<>(5);

        for (int i = 0; i < 5; i++) {
            arrayList.add(i + "");
        }

        ListIterator<String> listIterator = arrayList.listIterator();
        arrayList.remove(4);
        listIterator.next();
    }

执行后会抛出异常：

这里抛出异常应该的，如果迭代器和arraylist同时修改elementData，如果使用者不了解其中细节，大概率会出现问题。下面分析是什么机制让迭代器检测到并发问题并抛出异常。

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

在初始化迭代器时，会将expectedModCount 指定为modCount的值，然后看next方法：

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

在第一行看到一个checkForComodification()，继续跟进

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

看到这里我们就全明白了，当我们得到arraylist的迭代器时，会将expectedModCount的值指定为modCount，之后如果继续通过list执行增删操作，那么这里的判断modCount != expectedModCount就会成立，那么就会抛出ConcurrentModificationException异常！