ArrayList详解

最新推荐文章于 2024-03-30 15:28:13 发布

ID-柒

最新推荐文章于 2024-03-30 15:28:13 发布

阅读量348

点赞数

分类专栏： java集合文章标签： java 集合数据结构 arraylist

转载请附带链接

本文链接：https://blog.csdn.net/hugeshuai/article/details/116196568

版权

java集合专栏收录该内容

3 篇文章 0 订阅

订阅专栏

ArrayList是Java中实现动态数组的数据结构，继承AbstractCollection，实现了List接口。它允许null值和重复元素，基于数组进行动态扩容。在添加元素时效率高，查询速度快，但删除和插入元素时需要复制大量元素，性能较低。线程不安全，可通过Vector或Collections.synchronizedList使其变得线程安全。

摘要由CSDN通过智能技术生成

ArrayList集合详解

参考https://blog.csdn.net/sihai12345/article/details/79382649

1、简介

ArrayList继承自AbstractCollection类，实现了List接口，底层基于数组实现了容量大小的动态变化，允许null值存在，支持快速访问、复制和序列化。

 //默认初始容量大小为10
    private static final int DEFAULT_CAPACITY = 10;
    //从有参构造函数初始化
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //从空的构造函数初始化
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //真实数组
    transient Object[] elementData; 
    //实际元素个数
    private int size;

    //被定义在AbstractCollection中，用来记录List操作次数，主要是防止迭代过程中内容被修改
    protected transient int modCount = 0;

    //每次添加新元素就把size加1，记录数组中保存元素的个数
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }   
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //数组扩容，每次扩容为原来容量的1.5倍。
    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);
    }
    //最大存储为Integer.MAX_VALUE
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    //把指定元素后面所有元素，利用System.arraycopy方法向前整体移动一位
    //然后把最后一个元素值指定为null，这样GC就会回收。
    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;
    }