ArrayList源码分析(基于JDK1.8)

时间：2021-12-17 19:32:56

ArrayList的继承关系

ArrayList源码分析(基于JDK1.8)


ArrayList的成员变量

//初始化默认容量 private static final int DEFAULT_CAPACITY = 10; // 空对象数组 private static final Object[] EMPTY_ELEMENTDATA = {}; // 默认容量的空对象数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 实际存储对象的数组 transient Object[] elementData; // 存储的数量 private int size; // 数组能申请的最大数量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;


1.add(E e)，最常用的，其他添加元素的方法和这个方法的实现都差不多

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

在添加元素之前，所有方法都会进行一次检查，是否需要进行扩容，如果在指定位置添加元素，则会调用rangeCheckForAdd(index)对index进行检查，是否越界
重点看一下ensureCapacityInternal(size + 1)方法

 private void ensureCapacityInternal(int minCapacity) {
        //这个判断是针对默认构造函数
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //在小于10之前最大值一直都是DEFAULT_CAPACITY
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

为什么说那个if判断是针对默认构造函数的呢

默认构造函数：

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

而Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
其实默认构造函数并没有对elementData进行初始化
而非默认构造函数，比如：

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

是直接对elementData进行了一个初始化的
ensureCapacityInternal(int minCapacity)方法会调用ensureExplicitCapacity(minCapacity)方法

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

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

modCount记录的是对数据结构进行修改的次数
如果添加了一个数组元素以后会导致数组溢出，就会进行扩容，真正进行扩容操作的是grow()函数

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
       //扩大为原来的1.5倍
        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);
    }

所以对于调用默认构造函数时，数组的初始化是在第一次添加元素的时候调用grow()函数进行初始化的，对于已经初始化的容器，扩容以后扩大为原容器的1.5倍，而对于没有进行初始化的容器（即调用默认构造函数）初始化为10。如果扩容以后超过最大值将调用hugeCapacity(int minCapacity)方法

 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.5倍），则只能扩容为最大值的大小

3.4.3 remove(int index)

public E remove(int index) { rangeCheck(index); // 修改计数器 modCount++; // 记录旧值，返回 E oldValue = elementData(index); // 计算要往前移动的元素个数 int numMoved = size - index - 1; //个数大于0，进行拷贝，从index+1开始，拷贝numMoved个，拷贝起始位置是index if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); // 设置为null，以便GC elementData[--size] = null; return oldValue; }

对于被删除的元素，其后面的元素需要往前移。

3.4.4 remove(Object o)

public boolean remove(Object o) { // 判断o为null，loop遍历找到为null的元素 if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } // 不为null } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } // 与上面的remove(int index) 类似 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; }

3.4.5 set(int index, E element)

public E set(int index, E element) { rangeCheck(index); // 记录旧的值 E oldValue = elementData(index); //在原位置设置新的值 elementData[index] = element; return oldValue; }

设置index位置的元素值为element，返回该位置的原来的值

3.4.6 addAll(Collection<? extends E> c)

public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; // 对于新的最小长度进行判断处理 ensureCapacityInternal(size + numNew); //将a数组，从index-0开始，拷贝numNew个，到elementData的size位置 System.arraycopy(a, 0, elementData, size, numNew); //将size增加numNew个 size += numNew; return numNew != 0; }
转载来自：https://www.imooc.com/article/22259 
https://www.jianshu.com/p/aa582f6552b4

标签：

相关文章