ArrayList源码分析

ArrayList源码分析

private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
public ArrayList() {
    	// 无参数构造函数用默认的容量
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

public boolean add(E e) {
    	// 增加修改次数,并看看能不能放下,放不下就扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    	// 将数组复制后数组长度加一
        elementData[size++] = e;
        return true;
    }

public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew); 
		
    	// 如果是在中间插入,把原数组从插入处往后移,把要插入的数组插入
        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

// 计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 没数据,如果是add()方法进来的就定然会返回10
            // 没数据,如果是addAll()进来的,返回其中较大的一个
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
    	//数组中有数据,没添加以前是size,add()返回size + 1
        return minCapacity;
    }

// 确保能放下
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            // 放不下,扩容
            grow(minCapacity);
    }

// 扩容机制
private void grow(int minCapacity) {
        // 假如旧的容量是10
        int oldCapacity = elementData.length;
    	// 新容量就是15,扩大1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	// 扩容了还放不下
        if (newCapacity - minCapacity < 0)
            // 新容量直接设置成minCapacity
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 扩容后超了,判断minCapacity是否大于MAX_ARRAY_SIZE,大于就将数组长度设成Integer.MAX_VALUE,否则设成minCapacity
            newCapacity =MAX_ARRAY_SIZE hugeCapacity(minCapacity);
        // 复制数组到新数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

public E get(int index) {
    	// 判断是否大于容量,大了就报错 
        rangeCheck(index);
		// 获取数组并强转
        return elementData(index);
    }

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; 

        return oldValue;
    }

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
public int indexOf(Object o) {
    	// for循环遍历
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }