ArrayList 源码分析

关于List与ArrayList,在文档中是这么说明的
List:有序集合(也称为序列 )。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引(列表中的位置)访问元素,并搜索列表中的元素。
ArrayList:可调整大小的数组实现List接口。 实现所有可选列表操作,并允许所有元素,包括null 。 除了实现List 接口之外,该类还提供了一些方法来操纵内部使用的存储列表的数组的大小。 (这个类是大致相当于Vector,不同之处在于它是不同步的)。

现在我们从源码来深入了解ArrayList的常用方法(添加,插入,删除,修改,查询),这里分析的代码是基于jdk1.8的.

先来了解一下ArrayList的几种构造方法:

// 不指定长度
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 ArrayList(Collection c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 用空数组替换
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

这里有个地方挺有意思的: c.toArray might (incorrectly) not return Object[] (see 6260652)
c.toArray可能不返回Object[],可以看这个if的逻辑也是如果不是Object[]类型则按照Object[]类型生成一个数组并且赋值给elementData。这里有必要提一下为什么需要这么处理,我先贴一段代码跑一遍

Integer[] ags = {123,4545};
List a = Arrays.asList(ags);
List b = new ArrayList<>(a);
fe9075cac5198faef0a25fc30cf452c.png

再贴一段代码平复下心情 (说再多不如贴代码)

Integer[] ags = {123,4545};
List a = Arrays.asList(ags);

List b = new ArrayList<>();
b.add(1);

System.out.println(a.toArray().getClass() == Object[].class);    // false
System.out.println(b.toArray().getClass() == Object[].class);    // true

可以看到,同样类型的两个List转成数值获取class后去问Object[]比较,得到的结果竟然是不一样的,这是因为通过Arrays转换成的List,保留了原来的类型,这样子就有问题了啊,我是Integer类型通过Arrays.asList 转成了 List ,那么我通过list.toArray 转回来的时候你特么给我个Object[]类型,那我这时候我存个String类型进去会怎么样?

Integer[] ags = new Integer[5];
ags[0] = 1;
ags[1] = 2;
List a = Arrays.asList(ags);
Object[] test= a.toArray().clone();
test[2] = "123";

运行结果:
Exception in thread "main" java.lang.ArrayStoreException: java.lang.String

贴上BUG详情: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652

ArrayList 属性:

private static final int DEFAULT_CAPACITY = 10;       // 默认长度
private static final Object[] EMPTY_ELEMENTDATA = {}; // 用于空实例的共享空数组实例
transient Object[] elementData;        // 存储数据的数组
private int size;                      // 包含的元素的数量

ArrayList 方法(挑几个使用比较多的方法琢磨一下):

add(E e)方法: 将元素添加到集合的最后面

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}

// 确保add操作
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 为空的话 返回默认长度
private static int calculateCapacity(Object[] elementData, int minCapacity) {
     // Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
     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);
}

// 新长度 = 旧长度 + (旧长度 * 0.5)
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
    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);
}

// 如果新长度大于List的最大长度
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

先校验我这次add是不是超过了集合的最大长度,如果超过了,则新增一个扩容后的数组,并把原先的数组中的元素拷贝到新集合中,再把新增的元素添加到新数组中。

add[int index,E element]: 将元素添加到指定位置

public void add(int index, E element) {
    // 校验index 是否合法
    rangeCheckForAdd(index);
    // 确保add操作
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 如果是往最后添加,则忽略,如果是往中间插入,把index及index往后的元素向后移动
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 赋值
    elementData[index] = element;
    size++;
}

addAll(Collection c):将指定集合的所有元素,按照顺序追加到集合尾部

public boolean addAll(Collection c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保添加
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 讲指定集合的所有元素,拷贝到集合的最后面
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

remove(int index):删除指定位置的元素

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);
    // 最后位设置为null
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

remove(Object o): 删除匹配指定对象的元素

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    modCount++;
    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
}

这里的逻辑跟remove(int index) 方法其实没什么区别,就加了个循环,object为null的话,就把为匹配到的首个元素给删除,然后根据该被删除元素的索引去进行移动后面元素的操作。

removeAll(Collection<>?> c):从该列表中移除指定集合中包含的所有元素

public boolean removeAll(Collection c) {
    // 校验是否为null
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}


private boolean batchRemove(Collection c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        // 先将不存在目标集合中的元素设置在前列
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        // 防止出现异常,从异常开始位置往后的元素也会被设置进不满足条件列表
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        // 设置满足条件元素为null
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

remove这一系列的实现,其实还是挺简单的(其实都不难 (lll¬ω¬))

set(int,E element):设置索引位置的值

public E set(int index, E element) {
    // 校验index
    rangeCheck(index);
    
    // 获取对应元素
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

clear(): 清除list

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

设置所有的元素为null,size清0

感觉也没啥其他的方法了....ArrayList就到这吧 (lll¬ω¬)

总结:
1.ArrayList是一个有序列表,允许加入null元素
2.当我们按照索引来插入/删除时,会导致数组移位,当数据量很大的时候,是很消耗性能的
3.ArrayList的最大长度是 Integer.MAX_value - 8

你可能感兴趣的:(ArrayList 源码分析)