【类集源码】ArrayList的源码分析。

最新推荐文章于 2022-11-06 14:56:18 发布

程序瑶

最新推荐文章于 2022-11-06 14:56:18 发布

阅读量308

点赞数 1

本文链接：https://blog.csdn.net/qq_39487033/article/details/96576013

版权

ArrayList

一、构造方法

1.无参构造。

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

而elementData是类中的一个属性，数据类型为数组。

 transient Object[] elementData;

DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个默认的空数组。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

所以说用无参构造创建ArrayList的时候，一开始只是创建了一个空数组。

2.参数为int类型的有参构造

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

可以看到判断传入的int型参数的值，
如果大于0就创建一个参数值大小的数组进行初始化ArrayList。
如果小于0那么直接抛出异常。
如果等于0就将数组赋值为EMPTY_ELEMENTDATA（空数组）。

private static final Object[] EMPTY_ELEMENTDATA = {};

3.参数为Collection<? extends E> c类型的有参构造

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

这个方法刚进来，就将参数中的Collection集合转换为数组，赋值给elmentData。
如果这个转化后的数组大小为0，就初始化为EMPTY_ELEMENTDATA（空数组）。
否则就将转化之后数组的值，转换为Object[]赋值给elementData。

二、方法trimToSize()

 public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

这个方法就是将ArrayList的数组长度缩小，缩小到和当前存储元素的数量size一样的大小。需要注意的是：因为修改了数组的结构，所以modCount属性+1.

三、contains方法

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

这个方法是检验集合中是否包含某个元素，底层调用了indexOf方法。下面看看indexOf方法。

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

indexof方法通过遍历集合，寻找集合中是否存在某个元素，如果存在就返回它所在的下标（这时候返回的是从左到右遍历最先碰到所找元素的下标），如果不存在就返回-1.这也就解释了contains方法为什么要比较indexOf(o) >= 0;
ArrayList中还有一个方法是lastIndexOf(Object o) ，它也是查找元素所在的下标，不过是从右到左遍历最先碰到所找元素的下标就返回。

四、clone方法

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

ArrayList的clone方法调用的是Object的clone方法，所以它实现的是浅拷贝，也就是两个ArrayList的对象将指向同一块数组空间。新创建的集合对数组内对象的成员变量进行set将反应到旧集合中。而新创建的集合进行remove操作，或者add操作将不会影响旧集合。原因是，新集合的elementData是通过copyOf方法得到的数组，所以它引用了就集合中数组元素的地址，可以对其中的元素做修改，但是add和remove方法修改的是新集合的elementData的指向，所以不会影响到旧数组。
在这里插入图片描述

五、Get方法

 E elementData(int index) {
        return (E) elementData[index];
    }  

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

        return elementData(index);
    }

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

get方法就是先判断输入的下标是否正确，如果不正确就抛出异常。正确的话就调用elementData方法返回数组元素。

六、set方法

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

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

先检查下标，然后将数组的对应下标处的值保存起来，再修改对应下标的值，最后返回修改之前的值。

七、add方法（重要）

有两个add方法，先看只有一个参数的add方法。（尾插数据）

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

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

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

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

首先调用了ensureCapacityInternal方法，参数为当前数组内元素个数+1.而ensureCapacityInternal方法刚进去就判断当前elementData数组是否为空数组（因为ArrayList的初始化发生在add方法中）

如果为空数组，就取DEFAULT_CAPACITY（默认值为10）和传入参数minCapacity（因为是空数组，所以值一般为1）它俩中的最大值，所以minCapacity将得到新值10.然后进入下一个方法中，modCount+1（这个变量记录数组被修改的次数）。然后因为是空数组，所以10-0>0进入grow方法。这是ArrayList的扩容策略，在当前情况下，它会返回一个大小为10的数组。
如果数组不为空，直接调用ensureExplicitCapacity方法，参数是size+1，然后比较size+1 - 当前数组长度是否大于0.。如果不大于，说明数组还没满，就不用做任何操作，直接往数组后面直接插入。如果大于0，说明需要存储的元素个数已经大于数组长度了，需要扩容。在扩容策略中，当前情况将数组长度扩容为之前的1.5倍。

然后我们看参数为2个的add方法。（往指定下标插入数据）

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

先检查下标，然后判断是否进行初始化数组或者扩容策略。最终使用System.arraycopy方法进行数组的拷贝。

arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

参数src代表原数组，srcPos代表从原数组的哪个地方开始拷贝，dest代表目标数组，destPos代表将要赋值到目标数组的哪个位置，length代表需要复制的长度。
总之就是需要将数组元素挨个移动才能完成插入。

八、remove方法

remove方法有两个，一个是按下标删除，另一个是按数组中的数据删除。先看前者：

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

检查下标，然后修改数组了所以modCount++。并且保存旧元素。接下来的主要逻辑就是，判断需要删除的元素是否是最后一个，如果不是最后一个就需要进行数组的移动。否则就直接删除，然后将删掉的哪个元素置为null，让JVM帮我们回收。
接下来看参数为数据的：

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; // clear to let GC do its work
    }

逻辑很简单，就是循环遍历数组找需要删除的元素，找到之后调用fastRemove方法传入下标，因为下标肯定在数组内，所以不需要检查下标，并且这个方法的返回值不要求返回被删除元素，所以也不需要保存。因此只需要判断是否需要进行数组移动，就删除元素了。

九、addAll方法

有两个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;
    }

将参数中的所有元素，复制到数组尾部。根据扩容策略，如果插入的数量，比原数组的1.5倍还多，就直接将element数组扩容为size+numNew的大小。
另一个方法是在指定位置插入一组元素，多了一步拷贝数组的操作。

十、removeAll和retainAll方法

public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

 public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
    
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++)
                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;
    }

removeAll方法表示删除本类集中，所有与参数类集有交集的元素。
retainAll方法表示删除本类集中，所有与参数类集中无交集的元素

十一、ListIterator方法和iterator方法

public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
    
public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

这两个方法的区别就是，传入index参数的返回的是从index下标开始往后的迭代器。

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

Iterator和ListIterator的区别：

iterator()方法在set和list接口中都有定义，但是ListIterator（）仅存在于list接口中（或实现类中）；
ListIterator有add()方法，可以向List中添加对象，而Iterator不能。（add方法是在当前迭代器的位置向List集合中插入元素）
ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
ListIterator可以定位当前的索引位置，nextIndex()返回下一个下标和previousIndex()返回当前下标可以实现。Iterator没有此功能。
都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

十二、subList方法

public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }

第一个方法是检查下标，判断是否抛异常。然后就是返回一个SubList的内部类。

该方法返回的是父list的一个视图，从fromIndex（包含），到toIndex（不包含）。fromIndex=toIndex 表示子list为空
父子list做的非结构性修改（non-structural changes）都会影响到彼此：所谓的“非结构性修改”，是指不涉及到list的大小改变的修改。相反，结构性修改，指改变了list大小的修改。
对于结构性修改，子list的所有操作都会反映到父list上。但父list的修改将会导致返回的子list失效(抛出异常)。

十三、forEach方法

public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

调用forEach方法的时候，需要传入一个类型为Consumer的参数，这是一个接口，如果用匿名类的形式，就得自己覆写这个接口中的accept方法，然后在forEach方法中遍历了accept方法。如果不用匿名类的形式，就是自己写一个类实现Consumer接口，然后覆写accept方法，这时候传入的参数就是自己实现的类，调用的accept方法也是这个类覆写的方法。