面试-ArrayList基础

/**
 * 默认的数组长度为10
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 这个数组就是ArrayList底层实现用于保存元素的数组
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 当前数组中包含的真实有效的元素的个数
 */
private int size;

 //开始代码调用
 List<String> list = new ArrayList<>();
 list.add("a");
 
 //ArrayList源码：
 //首先看看add方法
 public boolean add(E e) {
    // 首先确保数组长度满足元素的存储的要求，传递的参数值为当前数组长度+1
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e; //将新加入的元素
    return true;
 }
 
 private void ensureCapacityInternal(int minCapacity) {
    //若默认的数组此时为空数组的话，计算是应该创建默认大小的数组还是创建当前数组长度+1长度的数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

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

    // 若当前为了存储a而需要的数组的长度大于当前数组的真实长度话，说明数组长度已经不够用，需要动态生成一个新的数组
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
 }
 
 //动态生成新数组
 private void grow(int minCapacity) {
    // 旧数组的长度
    int oldCapacity = elementData.length;
    // 新数组的长度为旧数组长度的1.5倍。右移运算符相当于除以2
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 采用数组拷贝的方式动态创建出一个新数组，原来的数组的内容不变；新数组中未赋值的元素值为null
    elementData = Arrays.copyOf(elementData, newCapacity);
 }

// 整体来说，删除元素的思路为
// 加入原始数组存在五个元素 a b c d e ，当调用remove(2)时，
// 需要将index为3和4的对应的值，依次向左移动 此时数组中元素的值为a b d e null
// Java是如何移动元素的呢，就是调用了一个native方法System.arraycopy()
public E remove(int index) {
    // 判断要删除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; // clear to let GC do its work

    return oldValue;
}

/* 数组元素移动的native方法签名
 * @param      src      原数组
 * @param      srcPos   从元数据的起始位置开始
 * @param      dest     目标数组
 * @param      destPos  目标数组的开始起始位置
 * @param      length   要copy的数组的长度
 */
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

Collections.synchronizedList(list);

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            // 其实返回的这个对象，而SynchronizedList对象提供的方法其实和ArrayList是一样的，不同的是其
            // 对每个方法的访问使用的同步锁
            new SynchronizedList<>(list));
}

// 可以看到SynchronizedList使用的锁mutex就是一个Object对象

// 省略不关注的代码...
final Object mutex;     // Object on which to synchronize
// 省略不关注的代码...

static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;

    final List<E> list;

    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    SynchronizedList(List<E> list, Object mutex) {
        super(list, mutex);
        this.list = list;
    }

    // 省略不关注的代码...

    public E get(int index) {
        synchronized (mutex) {return list.get(index);}
    }
    public E set(int index, E element) {
        synchronized (mutex) {return list.set(index, element);}
    }
    
    // 省略不关注的代码...
}