常见的List接口的实现类---ArrayList

一介烂人ぶ谩骂随心

已于 2022-09-05 00:10:45 修改

阅读量311

点赞数 2

文章标签：链表数据结构 java

于 2022-09-04 23:37:48 首次发布

本文链接：https://blog.csdn.net/tiger_root/article/details/126696234

版权

List接口的实现类

ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)

ArrayList的使用与实现(源码分析)

类定义

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; 当前集合中存储的元素个数

构造器

public ArrayList() {
       	//针对存储数据的数组进行初始化操作
       	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
       	//常量定义为DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};空数组
       	//如果使用无参构造器，则不会直接创建数组，而是采用空数组，当第一次添加元素时才创建数组
       	//使用无参构造器时ArrayList会构建一个空数组用于未来存放数据，这里是一种对内存消耗的优化处理
}
    	
    	
带参构造器   List list=new ArrayList(18) 
    	    18就是初始化容积，这里的初始化参数值必须为[0,int的最大值)
    	
public ArrayList(int initialCapacity) {  //参数为初始化容积  initial初始化  capacity容积
	    if (initialCapacity > 0) {  如果初始化容积大于0，则按照指定的容积创建数组
	         this.elementData = new Object[initialCapacity];
	    } else if (initialCapacity == 0) {
	         this.elementData = EMPTY_ELEMENTDATA;  空数组,长度为0的数组
	    } else {  //初始化容积值小于0则报异常
	         throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
	    }
}

add的方法定义

    protected transient int modCount = 0;  transient不被序列化
	
	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) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            //调用Arrays工具类中的方法进行数组的拷贝,同时调用newCapacity方法计算所需要的新容积值
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }
    
    //数组的拷贝操作定义在Arrays工具类中，copyof会新建一个指定长度newLength的数组，并且将原始                
    //数组中的所有元素拷贝到新数组中，同时返回新创建的数组参数1是原始数组，参数2为所需要的新长度
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
    
    
    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，则返回最大整数值，否则返回最大允许的容积值
    }


    由于在不同的平台上，受到平台的影响导致能够为数组分配的实际最大数值并非
	为Integer.MAX_VALUE(2,147,483,647)，而是与这个值相接近的数值。因此，
	作者减8实际上是因为不想让你创建的数组在扩容时计算的新容量值等于或过于
	接近最大值不能被平台分配出来而报出OOM错误。

    //数组长度的上限值
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

结论：
- 如果直接初始ArrayList，则采用延迟初始化处理【初始化数组长度为0】的方式以节约内存，当添加数据时，才进行数组的初始化，默认初始化容积为10

- 添加数据时当存储数据的数组长度不足时，数组会自动变长，变长的比例为原容积的50%

删除元素remove

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

    @ForceInline
    public static int checkIndex(int index, int length) {
        return Preconditions.checkIndex(index, length, null);
    }

    @IntrinsicCandidate
    public static <X extends RuntimeException> int checkIndex(int index, int length,
                   BiFunction<String, List<Number>, X> oobef) {
        if (index < 0 || index >= length)
            throw outOfBoundsCheckIndex(oobef, index, length);
        return index;
    }

    //迭代器的实现类中定义【内部类】
    private void checkForComodification(final int expectedModCount) {
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();//并发修改异常
        }
    }