ArrayList源码笔记

最新推荐文章于 2023-01-24 15:40:26 发布

老王同鞋

最新推荐文章于 2023-01-24 15:40:26 发布

阅读量281

点赞数

分类专栏：兜兜转转躲不过命运二字文章标签： java

本文链接：https://blog.csdn.net/qq_46016042/article/details/108529971

版权

兜兜转转躲不过命运二字专栏收录该内容

12 篇文章 0 订阅

订阅专栏

参考文档：

https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/collection/ArrayList.md

ArrayList简介

ArrayList是基于数组实现的

它实现了List, RandomAccess, Cloneable, java.io.Serializable接口

可以添加、修改、删除、遍历等，可以随机访问、克隆、序列化。

构造方法

ArrayList(int initialCapacity)

public ArrayList(int initialCapacity) {
    // 如果传递的初始化容量大于0
    if (initialCapacity > 0) {
        // 创建一个新的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 等于0的话，将当前数据设置为空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

ArrayList()

public ArrayList() {
    // 不指定容量，默认为一个空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(Collection<? extends E> c)

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    // 判断当前数组是否为空
    if ((size = elementData.length) != 0) {
        // 如果当前数组的类型不是Object类型
        if (elementData.getClass() != Object[].class)
            // 将当前数组转换成Object类型的数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果数组为空，设置为空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

contains方法

判断ArrayList是否包含指定元素

contains(Object o)

public boolean contains(Object o) {
    // 判断当前对象是否存在数组中，存在返回索引，不存在返回-1
    return indexOf(o) >= 0;
}

int indexOf(Object o)

// 从前向后查找数组是否存在指定元素
public int indexOf(Object o) {
    // 判断当前对象是否为空
    if (o == null) {
        // 遍历数组
        for (int i = 0; i < size; i++)
            // 判断当前数值中索引对应的值为null是返回索引
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            // 判断当前数值中索引对应的值与传递的值相同时是返回索引
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

lastIndexOf方法

// 从后向前查找数组是否存在指定元素
public int lastIndexOf(Object o) {
    // 判断当前对象是否为空
    if (o == null) {
        // 将数组从后向前逆向遍历
        for (int i = size-1; i >= 0; i--)
            // 判断当前数值中索引对应的值为null是返回索引
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            // 判断当前数值中索引对应的值与传递的值相同时是返回索引
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

clone()方法

// 返回对象的浅拷贝
public Object clone() {
    try {
        // 返回浅拷贝原因
        // 我认为是因为并没有创建一个新的ArrayList进行copy
        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);
    }
}

toArray方法

toArray()

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

toArray(T[] a)

// 将当前的ArrayList拷贝到传递的数组中，两个数据用一个null区分开
// 并不是很理解这个方法的作用
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // 如果传递的a数组长度比当前数组的长度小
        // 将当前数组转换成a类型的数组
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    // 将当前数组整体拷贝到传递的a数组中
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        // 将a数组中原数组长度的索引对应的值设置为null
        a[size] = null;
    return a;
}

get方法

@SuppressWarnings("unchecked")
E elementData(int index) {
    // 返回索引对应的值
    return (E) elementData[index];
}
// 获取指定索引对应的值
public E get(int index) {
    rangeCheck(index);	// 检查索引是否越界

    return elementData(index);
}

rangeCheck(int index)

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

set方法

// 将指定索引设置为指定的值，并返回原有的值
public E set(int index, E element) {
    rangeCheck(index);	// 检查索引是否越界
	// 获取原有的值
    E oldValue = elementData(index);
    // 重新赋值
    elementData[index] = element;
    // 返回原有的值
    return oldValue;
}

add方法

add方法，会自动扩容，ArrayList扩容的本质就是将现有的数组拷贝到一个新的大容量的数组中，自动扩容的容量为原有容量的1.5倍。

add(E e)

public boolean add(E e) {
    // size保存的是当前数组的大小，判断数组是否需要扩容
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;	
    return true;
}

add(int index, E element)

public void add(int index, E element) {
    rangeCheckForAdd(index);	// 检查指定的索引是否越界

    ensureCapacityInternal(size + 1);  // 是否需要扩容
    // 将当前数组指定位置到最后的所有数据向后移动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);	
    elementData[index] = element;  // 指定位置赋值
    size++;
}

System.arraycopy(elementData, index, elementData, index + 1,size - index)的作用理解图

在这里插入图片描述

ensureCapacityInternal

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 判断当前数组是否为空
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

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

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

    // 判断当前数组是否需要扩容
    // 传递的值比数组长度大时则需要扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

System.arraycopy()方法

/**
*src    	源数据 
*srcPos     源数据的起始索引
*dest       目标数据
*destPos    目标数据的索引
*length     数据长度
*/
public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

remove方法

remove(int index)

// 删除指定索引的数据
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; // 数组最后的位置设置为null

    return oldValue;	// 返回删除的值
}

remove(Object o)

// 删除指定数据
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
}

removeRange(int fromIndex, int toIndex)

删除一个区间内的元素，左闭右开[fromIndex,toIndex)

protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    // 从toIndex开始到最后的数组，移动到fromIndex位置
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

    // 将后面的值设置成null
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

reamoveAll方法

删除当前ArrayList中的包含的指定集合的所有元素

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

retainAll方法

保留当前ArrayList中的包含的指定集合中的所有元素

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

batchRemove(Collection<?> c, boolean complement)

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        // 当complement=true时,将集合中的所有元素依次移动到当前数组的头部
        // 当complement=false时,将集合中不包含的所有元素依次移动到当前数组的头部
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // 如果c.contains出现异常的话就把剩下的元素向前移动
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // 将所有不包含在指定集合中的元素都设置为null
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

ensureCapacity方法

public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        ? 0
        : DEFAULT_CAPACITY;
	
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

ensureExplicitCapacity(int minCapacity)

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

    // 底层是数组进行拷贝，所以传递的容量必须要比当前数据的容量大才能进行扩容
    if (minCapacity - elementData.length > 0)
        // 扩容
        grow(minCapacity);
}

grow(int minCapacity)

private void grow(int minCapacity) {
    // 原数组长度
    int oldCapacity = elementData.length;
    // 新数组长度设置为原有的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
   	// 数组扩容长度最少为原有的1.5倍，只有传递长度比newCapacity大的时候才能够使用传递的长度进行扩容
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 判断数组扩容后的长度是否超过数组最大长度，
    // Integer.MAX_VALUE - 8 = 2147483639,
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制当前数组的值并生成一个扩容后的数组，将数组的引用赋值给现有的数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    // 如果传递的扩容长度大于数组最大长度，
    // 将其设置成Integer的最大值
    // 否则将其设置为数组最大长度
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

clear方法

public void clear() {
    modCount++;

    // 遍历数组，将所有的值设置为null，最后由GC删除
    for (int i = 0; i < size; i++)
        elementData[i] = null;
	// 数组大小设置为0
    size = 0;
}

addAll方法

boolean addAll(Collection<? extends E> c)

将指定集合中的元素追加到当前的ArrayList后面

public boolean addAll(Collection<? extends E> c) {
    // 将传递的集合转成数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 判断当前数组加上传递的集合后是否需要扩容
    ensureCapacityInternal(size + numNew);  
    // 将传递的集合拷贝到当前数组的后面
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

boolean addAll(int index, Collection<? extends E> c)

将指定元素插入到ArrayList的指定索引位置

public boolean addAll(int index, Collection<? extends E> c) {
    // 判断索引是否越界
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    // 判断当前数组加上传递的集合后是否需要扩容
    ensureCapacityInternal(size + numNew);  
	// 计算指定索引到最后的元素的个数
    int numMoved = size - index;
    if (numMoved > 0)
        // 将当前数组向后移动传递的集合大小个位置
        // 如果传递的索引为1，集合大小为3
        // 则将当前数组从索引1开始到最后的所有数据，向后移动3个位置
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
	// 将指定集合元素拷贝进当前数组中
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}
ray();
    int numNew = a.length;
    // 判断当前数组加上传递的集合后是否需要扩容
    ensureCapacityInternal(size + numNew);  
	// 计算指定索引到最后的元素的个数
    int numMoved = size - index;
    if (numMoved > 0)
        // 将当前数组向后移动传递的集合大小个位置
        // 如果传递的索引为1，集合大小为3
        // 则将当前数组从索引1开始到最后的所有数据，向后移动3个位置
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
	// 将指定集合元素拷贝进当前数组中
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}