[面试源码] java8 ArrayList解析

最新推荐文章于 2024-05-27 13:44:21 发布

荼白z

最新推荐文章于 2024-05-27 13:44:21 发布

阅读量460

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/Zhang_0507/article/details/107303774

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

首先看ArrayList实现了 List ，RandomAccess , Cloneable , java.io.Serializable
其中的RandomAccess 代表其拥有随机快速访问的能力

因为其底层数据结构是数组，是占据一块连续的内存空间，所以其空间效率不高，但是可以根据下标读写（改查）元素，时间效率很高，当集合中的元素超出容量会进行扩容操作，新容量=旧容量*1.5

arraylist需要8字节来存储自己的信息，所以最大的容量就是 Integer.MAX_VALUE-8
下面来看代码，首先是构造函数

构造函数

构造函数可以指定容量也可不指定，如果不指定容量则默认返回一个空数组，在添加的时候会判断如果是空数组会默认容量大小为10 。

// 如果不指定容量默认返回一个空的对象数组    
public ArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

如果是自定义容量就会做一些判断，判断是否大于0，是否=0，超出最大值就设为最大值

// 定义初始容量的构造函数
public ArrayList(int initialCapacity) {
    // 如果容量大于0，创建一个具有初始容量的数组
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
        // 如果容量为0 则返回空数组
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 如果容量小于0 抛异常
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
}

添加

add()

直接添加元素（序号的顺序并不是执行的顺序，而是代表不同的方法，具体顺序看方法调用的顺序）

1.添加
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 在数组末尾追加一个元素，并修改size
    elementData[size++] = e;
    return true;
}

private static final int DEFAULT_CAPACITY = 10;
2.判断容量大小
private void ensureCapacityInternal(int minCapacity) {
    // 如果当前数组为空数组则扩容为默认容量大小10 
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
	
    ensureExplicitCapacity(minCapacity);
}
3.判断容量是否有效
private void ensureExplicitCapacity(int minCapacity) {
    // 修改指针增加
    modCount++;
	// 用容量-数组大小，如果大于0 则进行下一步操作
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
4.扩容
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);
}
5.查看最大容量
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?  Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

6. 根据class类型决定是new还是反射构造泛型数组，同时用native函数批量赋值元素至新数组中
public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength]  : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,  Math.min(original.length, newLength));
    return copy;
}

add(int index,E element)

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++;
}
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

addAll(Collection<? extends E>c)

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

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

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

总结：
add、addAll。
先判断是否越界，是否需要扩容。
如果扩容，就复制数组。
然后设置对应下标元素值。

值得注意的是：
1 如果需要扩容的话，默认扩容一半。如果扩容一半不够，就用目标的size作为扩容后的容量。
2 在扩容成功后，会修改modCount

删除

按索引删除元素

public E remove(int index) {
    //判断索引是否越界
    rangeCheck(index);
    //修改modeCount 因为结构改变了
    modCount++;
    //读出要删除的值
    E oldValue = elementData(index);
    // 要移动的元素数量
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //用复制 覆盖数组数据,删除元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //置空原尾部数据 不再强引用， 可以GC掉
    elementData[--size] = null;  
    return oldValue;
}

//根据下标从数组取值 并强转
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

按元素内容删除

//删除该元素在数组中第一次出现的位置上的数据。 如果有该元素返回true，如果false。
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);//根据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
    modCount++;
    //计算要移动的元素数量
    int numMoved = size - index - 1;
    //以复制覆盖元素 完成删除
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; //置空 不再强引用
}

批量删除

//批量删除
public boolean removeAll(Collection<?> c) {
    //判断集合是否为空，会抛异常
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
//批量移动
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;//w 代表批量删除后 数组还剩多少元素
    boolean modified = false;
    try {
        //高效的保存两个集合公有元素的算法
        for (; r < size; r++)
            // 如果 c里不包含当前下标元素
            if (c.contains(elementData[r]) == complement) 
                //保留
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) { 
            //出现异常会导致 r !=size , 则将出现异常处后面的数据全部复制覆盖到数组里。
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;//修改 w数量
        }
        if (w != size) {
            //置空数组后面的元素
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            //修改modCount
            modCount += size - w;
            // 修改size
            size = w;
            modified = true;
        }
    }
    return modified;
}

当用来作为删除元素的集合里的元素多余被删除集合时，也没事，只会删除它们共同拥有的元素。

小结：
1 删除操作一定会修改modCount，且可能涉及到数组的复制，相对低效。
2 批量删除中，涉及高效的保存两个集合公有元素的算法，可以留意一下。