Arraylist源码分析

有帮助的话对Micro极微完美女装品牌店淘宝店支持支持包

一、arraylist扩容问题（jdk8中arraylist源码）

API中对List得解释：List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

后面我们将会用到modCount，因为ArrayList被设计成非同步的，这个字段是判断列表结构是否改变的，他是一个瞬时状态，在迭代时如果这个字段大小和size不相等则代表在迭代期间列表发生了改变，将会抛出ConcurrentModificationException异常，我们在迭代时改变集合需要用到迭代器自带的方法。

 

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@Native public static final int   MAX_VALUE = 0x7fffffff;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }


 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

grow方法顾名思义便是扩容得方法.

ArrayList()构造一个初始容量为 10 的空列表。

我们获取到当前数组得长度

int oldCapacity = elementData.length;

创建一个新的int对象，将其初始化为oldCapacity 的1.5倍大小

int newCapacity = oldCapacity + (oldCapacity >> 1);

判断newCapacity 的大小和数组最小长度的关系，如果小于规定的大小则将数组大小调整为允许的最小长度

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

判断和MAX_ARRAY_SIZE 的关系，一旦大于MAX_ARRAY_SIZE 则跳入hugeCapacity方法判断

if (newCapacity - MAX_ARRAY_SIZE > 0)

newCapacity = hugeCapacity(minCapacity);

如果大于MAX_ARRAY_SIZE则将长度调整为Integer.MAX_VALUE否则调整为MAX_ARRAY_SIZE

(minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;

数组长度为Integer.MAX_VALUE则会抛出java.lang.OutOfMemoryError

二、在这里插播一个Arrays的简单介绍后面会出详细的讲解

jdk8中对Arrays解释：

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

再这里我们将会用到它的copyOf(boolean[] original,int newLength)方法：

复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 false。当且仅当指定长度大于原数组的长度时，这些索引存在。

三、trimToSize()

 

将此 ArrayList 实例的容量调整为列表的当前大小。

//transient 不可被序列化的状态，这个字段的生命周期仅存于调用者的内存中
protected transient int modCount = 0;
private static final Object[] EMPTY_ELEMENTDATA = {};
public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

modCount是每次java在调整内存时是1.5倍的提升，但是我们却用不完这个方法可以把多余的去除，在这里我们使用copyOf方法手动调整数组大小。

四、ensureCapacity（）

增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。

public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

从上面源码可以看出如果传进来的值大于默认值也就是10，我们则在此基础上调用ensureExplicitCapacity以达到在此基础上以java的扩容方式进行集合扩容操作。

五、contains（）

contains：如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        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;
    }

从源码看出此方法接受一个Object参数，调用indexOf方法，如果遍历出数组中有此对象则返回索引位置，也就是true，没有则返回-1，也就是fals。

六、clone（）

clone：返回此 ArrayList 实例的浅表副本。（不复制这些元素本身。）

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

浅克隆：复制对象时仅仅复制对象本身，包括基本属性，但该对象的属性引用其他对象时，该引用对象不会被复制，即拷贝出来的对象与被拷贝出来的对象中的属性引用的对象是同一个。

深克隆：复制对象本身的同时，也复制对象包含的引用指向的对象，即修改被克隆对象的任何属性都不会影响到克隆出来的对象。

从代码看出是创建一个list副本，将当前的数组赋值给副本并将modcount置为0；

七、toArray(T[] a)

toArray(T[] a)：按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳列表，则将该列表返回此处。否则，将分配一个具有指定数组的运行时类型和此列表大小的新数组。

如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），那么会将数组中紧接 collection 尾部的元素设置为 null。（仅 在调用者知道列表中不包含任何 null 元素时才能用此方法确定列表长度）。

arraycopy（）：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

toArray可以看出当我们复制完数组，大于数组长度的位置将会用null填充（我们传入的数组长度大于或者等于目标数组的大小）

当传入数组大小小于传入目标数组会调用copyOf方法，在里面创建一个可用长度（要复制的数组长度）的数组并完成复制操作进行返回。

八、add(int index, E element)

add(int index, E element)add(int index, E element)：将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

arraycopy方法在api中有这么一句解释：

如果参数 src 和 dest 引用相同的数组对象，则复制的执行过程就好像首先将 srcPos 到 srcPos+length-1 位置的组件复制到一个带有 length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的 destPos 到 destPos+length-1 位置一样。

那么这个arraycopy当前操作就相当于创建一个副本数组，并将传入的下标位置保留位null，下标后的位置往后移动，下一步对下标位置进行赋值就完成了在当前位置插入指定元素的操作。