ArrayList集合

小涂学编程

已于 2024-03-07 21:16:28 修改

阅读量5

点赞数

分类专栏： # 集合文章标签： java jvm servlet

于 2022-09-12 18:02:23 首次发布

本文链接：https://blog.csdn.net/qq_45905724/article/details/126818924

版权

集合专栏收录该内容

7 篇文章 0 订阅

订阅专栏

ArrayList集合

动态数组的结构（一个一个挨在一起），适合做遍历，不适合做插入和删除

ArrayList集合初始化容量是10。（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量10）

ArrayList集合底层是Object类型的数组Object[] （elementData）。

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) { //如果初始化容量>0
        this.elementData = new Object[initialCapacity]; //new一个Object数组
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

//默认初始化容量10
List myList1 = new ArrayList();

//指定初始化容量20
List myList2 = new ArrayList(20);

add()

跟C++ 的vector不同，ArrayList没有push_back()方法，对应的方法是add(E e)，ArrayList也没有insert()方法，对应的方法是add(int index, E e)。这两个方法都是向容器中添加新元素，这可能会导致capacity不足，因此在添加元素之前，都需要进行剩余空间检查，如果需要则自动扩容。扩容操作最终是通过grow()方法完成的。

ArrayList的add方法分析

先来看一下ArrayList的add方法：

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

在add方法中调用了ensureCapacityInternal方法，进入该方法一开始是一个空容器所以size=0传入的minCapacity=1：

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

然后通过calculateCapacity来计算容量：

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

会发现minCapacity被重新赋值为10 （ArrayList的初始化容量是是10）（DEFAULT_CAPACITY=10），传入ensureExplicitCapacity(minCapacity);这minCapacity=10，下面是方法体：

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  
            grow(minCapacity); //这里就是进行扩容的grow方法
    }
    
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); 
 //oldCapacity >> 1（每右移一位就是除以2，左移一位就是乘以2）
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

add(int index, E e)需要先对元素进行移动，然后完成插入操作，也就意味着该方法有着线性的时间复杂度。所以线性复杂度为（n）

ArrayList的扩容机制了解吗?

ArrayList是基于数组的集合，数组的容量是在定义的时候确定的，如果数组满了，再插⼊，就会数组溢出。所以在插⼊时候，会先检查是否需要扩容，如果需要则自动扩容。扩容操作最终是通过grow()方法完成的。（当前容量+1为minCapacity，数组长度为elementData.length ）

如果当前容量+ 1超过数组长度，就会进⾏扩容。

ArrayList的扩容是创建⼀个1.5倍的新数组，然后把原数组的值拷贝过去。如下方代码

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//原来的1.5倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);//扩展空间并复制
}

由于Java GC自动管理了内存，这里也就不需要考虑源数组释放的问题。

ArrayList底层是数组，怎么优化？

尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量。这是ArrayList集合比较重要的优化策略。

数组的优点：检索效率比较高（每个元素占用的空间大小相同，内存地址是连续的，知道首元素内存地址，然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。）
数组的缺点：随机增删元素效率比较低。另外，数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）
但是需要注意的是：向数组末尾添加元素，效率还是很高的。

这么多的集合中你用哪个集合最多？

答：ArrayList集合。
因为往数组末尾添加元素，效率不受影响。另外，我们检索/查找某个元素的操作比较多。

addAll()

addAll()方法能够一次添加多个元素，根据位置不同也有两个版本，一个是在末尾添加的addAll(Collection<? extends E> c)方法，一个是从指定位置开始插入的addAll(int index, Collection<? extends E> c)方法。跟add()方法类似，在插入之前也需要进行空间检查，如果需要则自动扩容；如果从指定位置插入，也会存在移动元素的情况。
addAll()的时间复杂度不仅跟插入元素的多少有关，也跟插入的位置相关。

Remove()

remove()方法也有两个版本，一个是remove(int index)删除指定位置的元素，另一个是remove(Object o)删除第一个满足o.equals(elementData[index])的元素。删除操作是add()操作的逆过程，需要将删除点之后的元素向前移动一个位置。需要注意的是为了让GC起作用，必须显式的为最后一个位置赋null值。

public E remove(int index) {
    rangeCheck(index);//下标越界检查
    modCount++;//会将modCount值加1，在使用迭代器进行遍历的时候，
//这里我们将expectedModCount=modCount，使之保持统一。
//使用Iterator迭代器进行删除集合元素，则不会出现并发修改异常。
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; //清除该位置的引用，让GC起作用
    return oldValue;
}

关于Java GC这里需要特别说明一下，有了垃圾收集器并不意味着一定不会有内存泄漏。对象能否被GC的依据是是否还有引用指向它，上面代码中如果不手动赋null值，除非对应的位置被其他元素覆盖，否则原来的对象就一直不会被回收。

set()

由于List底层是一个数组ArrayList，所以直接对数组的指定位置赋值即可。

public E set(int index, E element) {
    rangeCheck(index);//下标越界检查
    E oldValue = elementData(index);
    elementData[index] = element;//赋值到指定位置，复制的仅仅是引用
    return oldValue;
}

get()

由于底层数组是Object[]，得到元素后需要进行类型转换。

public E get(int index) {
    rangeCheck(index);//下标越界检查
    return (E) elementData[index];//注意类型转换
}

小涂学编程

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ArrayList集合

ArrayList是基于数组的集合，数组的容量是在定义的时候确定的，如果数组满了，再插⼊，就会数组溢出。因为数组扩容效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量。每个元素占用的空间大小相同，内存地址是连续的，知道首元素内存地址，然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量10）所以线性复杂度为（n）不足，因此在添加元素之前，都需要进行剩余空间检查，如果需要则自动扩容。
复制链接

扫一扫