ArrayList源码学习笔记

ArrayList总结

• 数组结构，查询快，增删慢
• 线程不安全

ArrayList分点详解

ArrayList继承实现情况

ArrayList 构造方法

//不需要序列化
transient Object[] elementData;
//1.无参构造方法
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
//2.带参构造方法，参数为集合初始长度
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
//3.带参构造方法，参数为集合
public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //JDK的设计缺陷（不是所有的Collection.toArray()方法都会返回Object[]类型，比如Arrays.asList(T... a).toArray().getClass()=T.class）
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList 扩容

1. 当前数组后直接新增元素

	//1.新增元素
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //数组默认初始长度
private static final int DEFAULT_CAPACITY = 10;
//2.确认当前数组长度是否满足新增需求
private void ensureCapacityInternal(int minCapacity) {
		//3.如果elementData是根据ArrayList的无参构造方法进行赋值，否则minCapacity就是入参值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //4.则初始化数组长度为10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
		
		//5.确认是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
		//fast-fail机制
        modCount++;
        //如果需要的数组长度大于当前数组长度，需要对当前数组扩容
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //这个数组长度是不会出现内存溢出的最大数组长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //6.数组扩容方法
    private void grow(int minCapacity) {
        // 当前数组长度
        int oldCapacity = elementData.length;
        //新数组长度等于（原来数组长度+1/2原来数组长度）
        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);
    }
    //7.所允许的最大数组长度还是不能满足当前数组长度，则数组长度取32位整型最大值
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

2. 数组指定位置新增元素

//1.指定位置新增元素
public void add(int index, E element) {
        rangeCheckForAdd(index);
        //判断数组长度是否满足需求
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //创建一个新数组，有插入位置前、插入位置插入位置后3个数组组成的新数组
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    //2.确认添加位置是否在当前数组的合理范围内，不在直接抛出数组越界异常
private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }