Log[集合类-ArrayList]_20.03.28

最新推荐文章于 2022-08-06 16:49:23 发布

stayform

最新推荐文章于 2022-08-06 16:49:23 发布

阅读量310

点赞数

本文链接：https://blog.csdn.net/qq_41097894/article/details/105160259

版权

一、简介
ArrayList是一个可变长度的数组。与数组的性质相似，查找效率高而插入删除效率低。
二、源码分析
继承关系图：
在这里插入图片描述
类继承与接口实现：

RandomAccess：随机访问接口，里面无任何方法，只是用来做标记，用法：某个类对象instance of RandomAccess 就表明这个类具有快速随机访问的能力，就比如说我们今天说的ArrayList;
变量：

private static final long serialVersionUID = 8683452581122892189L;    //
private static final int DEFAULT_CAPACITY = 10;//默认数组初始大小
private static final Object[] EMPTY_ELEMENTDATA = {};//实例化确定数组容量时用到的空的Object类型数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//实例化时不确定数组的容量时用到的空的Object类型数组
transient Object[] elementData;//实际存储元素的数组
private int size;//数组大小


无参构造函数：

```java
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}//elementData引用指向长度为默认长度的对象数组

有参构造函数：
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];//引用指向新的Object数组，初始长度为参数值
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;//参数为0的话，引用指向没有默认长度的对象数组
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

2.1 插入操作
2.1.1 尾部插入

     public boolean add(E e) {//size:当前实际有多少个元素
    ensureCapacityInternal(size + 1);  // 1.确定是否能放得下元素
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {//minCapacity 当前需要的数组大小
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//2.如果e=D 期望的最小容量为DEFAULT_CAPACITY和minCapacity之间的最大值，用于用无参构造创建数组第一次初始化时
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return 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);//将原数组的值赋值到新的数组中
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?//想要的容量大于MAX_ARRAY_SIZE,则将Integer.MAX_VALUE赋值给它
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

//总结：将当前size+1作为想要的最大容量传入扩容函数，首先判断本数组是不是由无参构造函数实例化而来且是第一次插入元素的
//如果是，扩容（初始化）至容量为默认容量10；如果不是，则进行下一步判断
//判断想要的容量是否大于数组的容量，如果大于，扩容值原数组的1.5倍，并将扩容后的数组容量与最大允许数组容量进行对比，如果大于最大允许容量，则进行大容量分配：想要的容量大于MAX_ARRAY_SIZE,则将Integer.MAX_VALUE作为新容量
//最后将原数组的值赋值到新数组中

2.1.2 指定位置插入

public void add(int index, E element) {
    rangeCheckForAdd(index);//检查下标是否越界

    ensureCapacityInternal(size + 1);  // Increments modCount!!确认是否需要扩容
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);//将index后的元素做后移一位处理
    elementData[index] = element;//新元素插入
    size++;
}

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));//越界抛异常
}

2.2 获取元素

public E get(int index) {
    rangeCheck(index);//检查越界

    return elementData(index);//返回索引对应的元素值
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
elementData(int index) {
    return (E) elementData[index];
}

2.3 删除
2.3.1

public E remove(int index) {
    rangeCheck(index);//检查越界

    modCount++;//结构性修改次数++
    E oldValue = elementData(index);//记录要删除的元素的值

    int numMoved = size - index - 1;//删除后数据的移动次数是numMoved次
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);//元素搬移
    elementData[--size] = null; // clear to let GC do its work显式将最后一位引用赋值为空，以便GC

    return oldValue;
}

2.3.2
//这个方法用于如果想删除指定的元素，而不知道这个元素的索引时，就把这个元素装箱（Integer等），把引用作为参数，就可以删除指定元素

public boolean remove(Object o) {
    if (o == null) {//从这里可以看出来，ArrayList是可以存储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;
}

2.3.3

//将整个ArrayList置Null size置0 以便垃圾回收
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

2.3.4 批量删除

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);//确认c不为null
    return batchRemove(c, false);
}

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}
//总体思想大概是：逐个找到元素，把元素聚集到某处，遍历内一块进行逐个删除
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;
}

2.4 替换某索引下的元素

 public E set(int index, E element) {
    rangeCheck(index);//判断越界

    E oldValue = elementData(index);//存储就元素
    elementData[index] = element;//新元素覆盖旧元素
    return oldValue;返回旧元素
}

2.5 获取指定元素的下标值

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

2.6 遍历（直接在ArrayList里定义了实现Iterator接口的内部类，类里实现了这个接口的方法）

//遍历方法
Iterator it = arrayList.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}
//迭代器的实现方法
public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;       // 下一个元素的index
    int lastRet = -1; // 上一个元素的index
    int expectedModCount = modCount;

    Itr() {}

    //实际上跟for循环差不多，就是判断当前索引有没有等于或超过数组size
    //区别就是将i++的操作挪到了跟他配套使用的next()方法里
    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;//i++操作
        return (E) elementData[lastRet = i];//返回数组元素值，并且将元素的下标赋值给lastRet
    }

//此方法不能单独使用，要和next()结合使用，而且会改变cursor的值，所以如果想:迭代完一遍——>删除最后一个数——>再按同样的方式迭代一遍  这种做法是行不通的
    public void remove() {
        if (lastRet < 0)//小于0表示没有元素，也就没必要删除了
            throw new IllegalStateException();
        checkForComodification();

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

//此方法的使用场景：在用next()进行遍历时，达到某种条件，这时候此方法出场处理剩下的元素
    @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++]);//通过重写accept()对元素进行你需要的操作
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();//为了防止你在重写accept()时对原集合进行修改，所以在这儿加个操作次数检验
    }

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

Tips:
问题1：一直不太理解到底为什么要用两个空数组把有参构造实例化和无参构造实例化区分开来。
从源码里看来区别如下：如果用无参构造，在第一次插入元素时，会将ArrayList的容量初始化为10，由此，后面的九次操作就不需要扩容；如果使用有参构造参数且参数为0，就意味着从一开始就按照1.5倍的方式去扩容，同样是存储十个数据，这种方法效率不比前者优（而且我有点想不出这种初始化方式的应用场景是什么）。
问题2：为什么要用transient修饰elementData
因为ArrayList的容量通常大于实际存储的元素数，如果将elementData整个序列化，就会造成空间浪费，在源码里的序列化方法中，只将实际存储了元素的空间进行序列化。

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

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