ArrayList的使用和实现

最新推荐文章于 2024-07-22 14:15:06 发布

码&

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量62

点赞数 1

分类专栏： eclipse 文章标签： java eclipse

本文链接：https://blog.csdn.net/qq_51222096/article/details/126549851

版权

eclipse 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

List list=new ArrayList();
public class ArrayList<E>
extends AbstractList<E> 通过继承抽象类可以共享所有公共方法
implements List<E>, 实现List接口
RandomAccess, 实现随机访问接口
Cloneable, 实现克隆接口
java.io.Serializable 实现序列化接口

   transient Object[] elementData; 真是存放数据的数组

   private int size; 当前集合中存储的元素个数

构造器：

add方法的定义[重点]

   protected transient int modCount = 0;

   public boolean add(E e) {
modCount++; 用于统计当前集合对象的修改次数
add(e, elementData, size); 参数1：新增元素；参数2：存储数据的数组；参数3：当前集合中存储的元素个数
return true; 返回true表示添加成功
}

private void add(E e, Object[] elementData, int s) {
   //如果数组已经存满了，则首先进行扩容处理
if (s == elementData.length) 判断当前集合中存储的元素个数是否和数组长度相等
elementData = grow(); 如果相等则进行扩容处理
elementData[s] = e; 在数组的指定位置存储元素
size = s + 1; 集合中所存储的元素个数
}

private Object[] grow() { //扩容处理方法
return grow(size + 1); //继续调用其它扩容方法，参数为当前存储个元素个数+1---最小容积
}

   private Object[] grow(int minCapacity) {
//调用Arrays工具类中的方法进行数组的拷贝,同时调用newCapacity方法计算所需要的新容积值
return elementData = Arrays.copyOf(elementData,newCapacity(minCapacity));
}


private static final int DEFAULT_CAPACITY = 10;

private int newCapacity(int minCapacity) { 计算所需要的新容积值
int oldCapacity = elementData.length; 计算原来数组的长度
//计算新容积值
int newCapacity = oldCapacity + (oldCapacity >> 1); 相当于是老容积增加50%，这就是扩容比
//计算出的新容积值是否满足所需要的最小容积值
if (newCapacity - minCapacity <= 0) {
   //如果存储数据的数组为初始化时的空数组，则计算默认初始化容积10和所需要最小容积值则最大值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // OOM内存溢出
throw new OutOfMemoryError();
return minCapacity;
}
//如果计算出的新容积值大于所需要的最小容积值
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
   //如果计算出的新容积值小于最大允许的容积值，则返回计算出的新容积
        (minCapacity > MAX_ARRAY_SIZE)
           ? Integer.MAX_VALUE
           : MAX_ARRAY_SIZE;
//如果计算出的新容积值大于最大允许的容积值并且minCapacity大于MAX_ARRAY_SIZE，则返回最大整数值，否则返回最大允许的容积值
}

   //数组长度的上限值
   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
         数组的拷贝操纵定义在Arrays工具类中，copyof会新建一个指定长度newLength的数组，并且将原始数组中的所有元素拷贝到新数组中，同时返回新创建的数组
         参数1是原始数组，参数2为所需要的新长度
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}


The maximum size of array to allocate (unless necessary).
Some VMs reserve some header words in an array.
Attempts to allocate larger arrays may result in
OutOfMemoryError: Requested array size exceeds VM limit
要分配的最大数组大小（除非必要）。一些虚拟机在数组中保留一些头
字。尝试分配较大的阵列可能会导致：OutOfMemoryError请求的数组大小超过VM限制
   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   由于在不同的平台上，受到平台的影响导致能够为数组分配的实际最大数值并非
   为Integer.MAX_VALUE(2,147,483,647)，而是与这个值相接近的数值。因此，
   作者减8实际上是因为不想让你创建的数组在扩容时计算的新容量值等于或过于
   接近最大值不能被平台分配出来而报出OOM错误。

结论：

如果直接初始ArrayList，则采用延迟初始化处理【初始化数组长度为0】的方式以节约内存，当添加数据时，才进行数组的初始化，默认初始化容积为10添加数据时当存储数据的数组长度不足时，数组会自动变长，变长的比例为原容积的50%

删除元素

public E remove(int index) {
        Objects.checkIndex(index, size);   //检查所需要删除位置下标参数是否在合理的范围内[0,size-1]，如果超出范围则报异常
        final Object[] es = elementData;  获取所存储的所有元素数组
        E oldValue = (E) es[index];  获取指定位置上的元素
        fastRemove(es, index);   利用System.arrayCopy的方法使用覆盖的方式删除指定位置上的元素
        return oldValue;  返回删除掉的元素
        
        //没有缩容处理
    }
    
    private void fastRemove(Object[] es, int i) {
        modCount++;   修改次数+1
        final int newSize;  
        if ((newSize = size - 1) > i) //size - 1就是可以删除元素的最大下标
            System.arraycopy(es, i + 1, es, i, newSize - i); 通过数组拷贝的方式覆盖掉指定位置的元素
        es[size = newSize] = null; //最后位置赋null值
        
        {1,2,3,4,5} 执行arrayCopy方法需要覆盖下标为2的元素{1,2,4,5,5}
    }

结论：

使用数组元素移动的方式实现元素的删除。注意：这里没有变小容积修改元素个数时会有modCount的修改--快速失败

 get方法的实现
   	 public E get(int index) {
        Objects.checkIndex(index, size);针对索引下标进行合法性验证
        return elementData(index);
	}
	
	E elementData(int index) {
        return (E) elementData[index];
    }
	
	迭代器的实现类中定义【内部类】
	private void checkForComodification() {
        if (modCount != expectedModCount) { 
            throw new ConcurrentModificationException(); 并发修改异常
        }
    }