ArrayList

ArrayList集合

基于动态数组，数组大小是可变的，可以进行添加和删除元素

ArrayList方法

初始化

List<Object> list1 = new ArrayList<>();//不设置初始容量
List<Object> list2 = new ArrayList<>(2);//设置初始容量
List<Object> list3 = new ArrayList<>(list2);//传入集合

新增元素

List<String> list = new ArrayList<>(16);
List<String> list2 = new ArrayList<>(Arrays.asList("A", "B", "C"));
list.add("1");//直接插入
list.add(1,"2");//根据下标插入
list.addAll(list2);//插入集合中的所有元素
list.addAll(5,list2);//从下标开始插入集合中的所有元素

删除元素

list.remove(0);//根据下标删除
list.remove("2");//根据元素删除
list.removeAll(list2);//把list中存在list2中的元素删除
list.removeIf(e->e.contains("T"));//删除包含T的元素
list.clear();//清空所有元素

获取元素

list.get(0);//获取元素

设置元素

list.set(0,"set")//根据下标设置元素

还有其他常用的方法比如size()，contains()，containsAll()，indexOf()，lastIndexOf()等等

添加元素扩容顶层分析

public class ArrayList<E> extends AbstractList implements List{
    
    //用于空实例的共享空数组实例。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    
    //存储数据的容器
    transient Object[] elementData;
    
    //默认容器长度
    private static final int DEFAULT_CAPACITY = 10;
    
    //数组最大长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //数组元素个数
    private int size;
    
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_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);
        }
    }
    
     public boolean add(E e) {
         //判断是否需要扩容
        ensureCapacityInternal(size + 1); 
         //存入数据
        elementData[size++] = e;
        return true;
    }
    									 //size + 1
     private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
     private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //为空数组时，使用无参构造创建对象时，第一次添加数据就会进入到此判断
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    
      private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//操作数
          //存满则扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    																
    private void grow(int minCapacity) {
     	
        int oldCapacity = elementData.length;
        //将原数组长度扩大1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //扩容后的长度小于（现长度+1）
        if (newCapacity - minCapacity < 0)
            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;
    }