Collection集合分析之ArrayList

最新推荐文章于 2023-01-01 17:56:44 发布

Aeolian钦

最新推荐文章于 2023-01-01 17:56:44 发布

阅读量150

点赞数

分类专栏： Collection JAVA 文章标签： java

本文链接：https://blog.csdn.net/weixin_45362971/article/details/117607864

版权

JAVA 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Collection

3 篇文章 1 订阅

订阅专栏

ArrayList

基础自AbstractList

实现了List，RandomAccess，Cloneable，Serializable接口

四常量

    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

DEFAULT_CAPACITY：默认的数组容量

构造函数指定数组大小时指定的Object数组

默认构造函数指定的Object数组，当我们插入第一个元素的时候才会进行初始化容量为10，然后插入元素。

MAX_ARRAY_SIZE：能指定的最大容量，容量过大可能会导致OOM。

两变量

transient Object[] elementData;
private int size;

elementData：存储元素的数组，不参与序列化

size：元素的个数

三构造函数

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

第一个构造函数：指定初始容量大小，如果大于0，则作为ArrayList容量的大小，尽量指定大小，这个大小最后符合业务的需求，不要太大，也不要小了，大了会占用多余的空间，小了扩容会消耗性能。如果等于0，则给他指定默认的常量数组EMPTY_ELEMENTDATA，小于0抛出异常IllegalArgumentException

第二个构造函数：给他指定默认的常量数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA。大小为0，意味着将在给元素的时候进行初始化容量大小，然后添加元素。

第三个构造函数：将实现了Collection接口的集合类的元素给ArrayList。首先我们给elementData形参的Collection数组，然后size赋值当前数组的大小，判断是否等于0，不等于在判断他是否是Object数组。如果不是则进行数组的拷贝，他使用了Arrays.copyOf，底层是使用了System.arraycopy，注意System.arraycopy是浅拷贝，意味着是基本数据类型是值复制，引用类型是引用拷贝（即副本发生变化，源也会发生变化）。如果size==0，那么跟第一个构造函数是一样的，会指定默认的常量数组EMPTY_ELEMENTDATA。

深拷贝和浅拷贝

**浅拷贝：**基本数据类型属于值的复制，副本发生变化，源不会变化，引用数据类型属于引用的传递，他不会在内存空间开辟一个新的内存空间存储，而是引用原有的地址，所以副本发生变化，源也会变化

**深拷贝：**基本数据类型的拷贝与浅拷贝一直，但是引用数据类型，他是在内存空间开辟了新的内存空间，然后将源的数据复制一份到新的内存空间，这样副本发生变化，源不会发生变化

拷贝都需要实现Cloneable接口，实现clone方法，

// 浅拷贝
@Override
public Object clone() {
    return super.clone();
}
// 深拷贝
@Override
public Object clone() {
    //深拷贝
    try {
        // 直接调用父类的clone()方法
        // 首先通过浅拷贝将基本数据类型进行拷贝
        Student student = (Student) super.clone();
        // 然后重写引用数据类型的clone方法，将他在进行一次拷贝，这样他就是个新的内存空间存储
        student.subject = (Subject) subject.clone();
        return student;
    } catch (CloneNotSupportedException e) {
        return null;
    }
}

常用方法

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

该方法用于返回元素o在数组中的下标，不存在返回-1，根据o是否为null进行分别判断，通过遍历实现。

contains

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

使用了index方法来判断是否元素o是否存在，判断是不是大于等于0；

lastIndexOf

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

indexOf是正序查找，这个是逆序查找

clone

    public Object clone() {
        try {
            // 通过调用父类的clone方法即Object的，这个方法是一个本地方法native
            ArrayList<?> v = (ArrayList<?>) super.clone();
            // 然后对这个elementData进行拷贝，也是浅拷贝
            v.elementData = Arrays.copyOf(elementData, size);
            // 设置修改次数为0，
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

返回一个ArrayList的浅拷贝，意味着clone的ArrayList的对象的引用和本身的是一致的。而且如果使用了泛型，对象也是引用的相同的。就是说这两个是一模一样甚至内存空间都在一个地方。

toArray

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

获取elementData数组，也是浅拷贝

get

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

        return elementData(index);
    }

返回指定下标的元素，首先判断这个下标是否合理，rangeCheck是一个私有方法，判断index是否大于等于size，大于抛出下标越界异常

为什么会手动抛出？

因为ArrayList的数组的容量可能会大于数组实际元素的个数。

set

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

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

设置指定下标的元素

老规矩，先判断这个是否大于等于size，然后获取他原先下标的元素，在进行覆盖，返回原先的元素。

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++;
    }
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

第一个add是在指定下标添加元素，原元素和之后的元素后移，所以会对index进行范围的判断，判断他是否大于size或者小于0，是则抛出异常。下一步进行容量的确认，是否能够容纳，如果不够就进行扩容，如果elementData是默认的数组常量DEFAULTCAPACITY_EMPTY_ELEMENTDATA的话，就判断size+1和默认的容量DEFAULT_CAPACITY谁大，扩容大的哪一个。然后将元素后移，在给指定位置添加元素

第二个add默认在末尾进行添加，即下标为size的位置，首先会判断容量，增加修改次数，

两个add在返回值上指定位置添加元素不返回，在末尾添加返回true。

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

第一个remove：移除指定下标的元素并且返回，检查下标是否大于等于size，然后获得该元素，计算该元素后的元素个数，通过System.arraycopy进行拷贝复制，前移，将下标size-1的位置置为null，方便gc回收。

第二个remove：移除指定元素，有则移除返回true，没有返回false，两种情况，判断是否为null，然后进行元素的判断，获得元素的下标，通过fastRemove方法进行移除

clear

    public void clear() {
        modCount++;

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

        size = 0;
    }

增加修改次数，全置为null，方便GC回收，size=0；

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;
    }
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

第一个addAll：将指定集合类的所有元素添加到末尾。和add类似

第二个addAll：将指定集合类的元素添加到指定下标开始，元素后移，和add类似，只不过进行了两次System.arraycopy操作。

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

我们可以对比两个方法，可以看见他们都调用了batchRemove方法，通过一个布尔值判断是删除指定集合内包含的元素，还是只保留指定集合内存在的元素。

    private boolean batchRemove(Collection<?> c, boolean complement) {
        // 首先获取当前集合元素的副本
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            // 判断当前元素是否存在，根据布尔值来进行填充
            // 当complement为false，意味着删除，因为只有c里面的元素在当前集合内不存在才会保留
            // 当complement为true，意味着保留，当c里面的元素在当前集合内存在，他才会保留下来
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // 当r != size时，表示r < size，并没有读取完，也就是说在我们for循环操作之后，刚好另外的线程添加了元素，这里就是将添加的元素添加到w下标的后面
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            // 当w != size 时，表示后面的元素已经不需要了，需要进行清空，也就是置为null
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                // 进行了size-w次修改操作
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }