Java-集合（手撕ArrayList底层源码）

源码场景

//ArrayList<String> list = new ArrayList<>(100);
ArrayList<String> list = new ArrayList<>();

list.add("小宇");
list.add("小蒲");
list.add("小康");

源码分析

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
   //外部操作数（记录添加和删除的次数）
   protected transient int modCount = 0;//3
}

public class ArrayList<E> extends AbstractList<E> implements List<E>{
	//默认容量
    private static final int DEFAULT_CAPACITY = 10;
    //空内容的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
	//默认容量的空内容的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //最大的容器容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //数据容器 - [小宇,小蒲,小康,null,null,null,null,null,null,null]
    transient Object[] elementData;
    //元素个数
    private int size;//3
    
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    //initialCapacity - 100
    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);
        }
    }
    
    //e - 小康
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }
    
    //minCapacity - 11
    private void ensureCapacityInternal(int minCapacity) {
        //使用无参构造创建ArrayList对象，第一次添加数据时进入的判断
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //minCapacity = Math.max(10,1); --> minCapacity = 10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    //minCapacity - 11
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 有溢出意识的代码
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//扩容
    }
    
    //minCapacity - 11
    private void grow(int minCapacity) {
        // oldCapacity - 10
        int oldCapacity = elementData.length;
        // newCapacity = 15
        int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容机制：1.5倍
        if (newCapacity - minCapacity < 0)
            //newCapacity - 10
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
       
        // 扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
    }
}

ArrayList底层数据结构是什么？

Object类型的一维数组

ArrayList默认初始化长度是多少？

10

ArrayList如何减少容器的伸缩性？

使用有参构造定义容量

ArrayList数组最大容量是多少？

Integer.MAX_VALUE-8

ArrayList数组最大容量为什么是Integer.MAX_VALUE-8？或 ArrayList数组最大容量为什么要减8？

减8是为了腾出空间存放数组的头部信息

ArrayList的扩容机制是什么？

是原来数组长度的1.5倍