集合框架学习-ArrayList01

构造方法

无参构造

List<> list = new ArrayList<>(); //无参构造方法创建一个ArrayList集合

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

在ArrayList()中的源码中，即在不传入参数的情况下，调用ArrayList()的无参构造方法，这里的elementData是源码中定义的一个

存储数组列表元素的数组缓冲区，数组列表的容量是此数组缓冲区的长度。

transient Object[] elementData; // non-private to simplify nested class access

而DEFAULTCAPACITY_EMPTY_ELEMENTDATA则是源码中定义的一个

用于默认大小的空实例的共享空数组实例。我们将其与EMPTY_ELEMENTDATA区分开来，以了解添加第一个元素时要膨胀多少。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

在ArrayList中定义了size来表示：

数组列表的大小（它包含的元素数）。

private int size;

采用无参构造创建的ArrayList集合的容量是0，在第一次添加元素的时候会进行扩容操作。

有参构造

传入int initialCapacity

List<> list = new ArrayList<>(5); // 创建一个大小为5的ArrayList集合

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);
        }
    }

从代码中我们可以看到，我们传入的参数，是这个ArrayList集合的容量，也就是说我们传入一个int类型的参数，假设为5，那么会在创建ArrayList的时候为其分配五个内存空间，如果为0，那么就会将EMPTY_ELEMENTDATA这个Object类型的数组赋值给elementData

private static final Object[] EMPTY_ELEMENTDATA = {};

这里的EMPTY_ELEMENTDATA 和上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是一个意思，只是名字不一样。
也就是说采用这种构造方法，可以指定ArrayList的容量，当我们像ArrayList中添加元素的时候，它会先检查elementData数组是否有足够的空间来存储新元素，如果有，就直接将新元素放入elementData数组中，如果没有就会创建一个新的更大的数组，并将原来的elementData数组中的所有元素复制到新的数组中，这样elementData数组的长度就会增加，也就是扩容操作。这样做的好处就是可以避免多次去分配内部数组的空间，提高效率。

如果我们指定了一个过大的容量，比如1000，但是我们实际上只要存储10个元素，那么就会有990个空位没有被使用，这些空位就会占用内存空间，但是没有任何作用 。这就会浪费内存空间。

因此，我们应该尽量避免浪费内存空间，合理地使用和管理内存资源 。在创建ArrayList对象时，我们应该根据我们要存储的元素个数来指定一个合适的容量，既不要过大也不要过小 。

传入Collection<? extends E> c

public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

这个构造方法需要我们传入一个Collection类型的集合，其中<? extends E>表示我们传入集合的泛型可以是E，也可以是E的子类型。

• 首先，调用c的toArray方法，将c中的元素转换为一个Object类型的数组a 。
• 然后，判断a的长度是否为0，如果不为0，说明c不是一个空集合，那么就继续执行下面的步骤 。
• 接着，判断c的类型是否是ArrayList，如果是，说明c已经是一个ArrayList对象，那么就直接将a赋值给elementData，这样就避免了多余的复制操作 。
• 如果c的类型不是ArrayList，那么就调用Arrays类的copyOf方法，将a中的元素复制到一个新的Object类型的数组中，并赋值给elementData。这里要指定复制的长度为size，也就是a的长度，以及复制的目标类型为Object[].class，这样就保证了elementData是一个Object类型的数组 。
• 如果a的长度为0，说明c是一个空集合，那么就将elementData赋值为一个空数组EMPTY_ELEMENTDATA 。
  以上就是ArrayList的三种构造方法

常见方法

add(E e)

List list = new ArrayList<>(); //这里我采用无参构造创建一个容量为0，类型为Integer类型的ArrayList集合

list.add(1);
System.out.println(list); // 输出：[1]
此时我向list集合中添加了一个元素，那么它是怎么将元素添加进去的呢

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

这是ArrayList中定义的add方法，形参就是我们定义的ArrayList时指定的泛型类型为Integer
因为我用无参构造方法创建的ArrayList，所以这里的size是0，他会先调用ensureCapacityInternal这个放法，来确保有足够的容量，因为我们要添加元素，所以我们传入我们需要的容量就是size + 1，也就是minCapacity的值为1

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

在ensureCapacityInternal这个方法中又调用了ensureExplicitCapacity这个方法，并在其中调用了
calculateCapacity这个方法，我们先看calculateCapacity()这个方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

这个方法中我们传入了elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA （这个在创建无参构造方法的时候已经说过了）和 minCapacity = 1这两个参数，所以返回值是Math。max(DEFAULT_CAPACITY, minCapacity),而DEFAULT_CAPACITY在源码中定义为

private static final int DEFAULT_CAPACITY = 10;

所以返回值为10（Math.max方法，取最大值）。
此时我们将int类型的返回值10传入ensureExplicitCapacity这个方法中：

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

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

这里我们发现，minCapacity变成了calculateCapacity这个方法返回的参数10，所以if语句中条件成立，我们需要执行grow方法，传入minCapacity的值为10：

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);
    }

在grow方法中，我们可以发现ArrayList的扩容机制：

newCapacity = oldCapacity + (oldCapacity >> 1);

也就是说每次扩容的值是原来的1.5倍，>> 1表示位运算，右移一位，通俗点就是原来的值除2
再加上oldCapacity ，就是原来的1.5倍。
那么我们第一次添加，elementData的值是0，所以oldCapacity 、newCapacity的值都是0，所以进入if判断，newCapacity 的值为我们传入的10，然后调用Arrays.copyOf方法

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

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;
    }

这里又调用了 System.arraycopy方法，这里我不清楚的是为什么不直接调用 copyOf(U[] original, int newLength, Class<? extends T[]> newType) 这个方法，而是通过copyOf(T[] original, int newLength)来调用它

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

这段代码是用Java语言编写的，它是System类中的一个静态本地方法，用于在数组之间复制元素。123

这段代码的参数和含义如下：

Object src：源数组，要复制的数组。
int srcPos：源数组的起始位置，要复制的元素的下标范围是srcPos到srcPos+length-1。
Object dest：目标数组，复制后的数组。
int destPos：目标数组的起始位置，复制后的元素的下标范围是destPos到destPos+length-1。
int length：要复制的元素的个数。
这段代码的作用是从源数组中取出length个元素，从srcPos开始，按顺序复制到目标数组中，从destPos开始。例如，如果源数组是{1, 2, 3, 4, 5}，目标数组是{6, 7, 8, 9, 10}，那么执行System.arraycopy(src, 1, dest, 2, 2)后，目标数组变成了{6, 7, 2, 3, 10}。

这段代码有一些注意事项和异常情况：

源数组和目标数组可以是同一个数组，但不能有重叠部分。
源数组和目标数组必须是同一类型或者可以相互转换的类型。
如果源数组或目标数组为null，会抛出NullPointerException异常。
如果srcPos、destPos或length为负数，或者超出了数组的范围，会抛出ArrayIndexOutOfBoundsException异常。
如果源数组和目标数组的元素类型不匹配，会抛出ArrayStoreException异常。

将原来的elementData扩容成一个新的，容量为10的数组。
再回到add()方法中

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

在进行扩容以后，便是将元素添加进来，也就是将e赋值给elementData数组的size的位置，然后size++，就是自增1.
所以我们定义的ArrayList集合list，可以输出一下

System.out.println(list.get(0));//输出：1

这里补充一下在grow中出现的hugeCapacity方法

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

这个方法会先判断传入的minCapacity是否合法，小于0，即为溢出
在看看进入hugeCapacity的条件

 if (newCapacity - MAX_ARRAY_SIZE > 0)

这里的MAX_ARRAY_SIZE定义为

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

这个值是为了避免在一些虚拟机中分配过大的数组导致的OutOfMemoryError，因为一些虚拟机会在数组中保留一些头部字节。
而Integer.MAX_VALUE定义为

@Native public static final int   MAX_VALUE = 0x7fffffff;

这个值是int类型的最大值
如果minCapacity大于MAX_ARRAY_SIZE，就返回Integer.MAX_VALUE，这是数组能够分配的最大长度。1这种情况下，可能会在一些虚拟机中发生OutOfMemoryError，但也可能成功，取决于虚拟机的实现。
如果minCapacity小于或等于MAX_ARRAY_SIZE，就返回MAX_ARRAY_SIZE，这是一个相对安全的数组长度，在大多数虚拟机中都能够分配成功。

get()方法

在ArrayList中的get()方法很简单

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

传入的参数是一个int类型的数据，表示下标，他先调用rangeCheck方法，传入下标，来判断这个下标是否合法

private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

这里的size因为在之前添加元素的原因，目前的值是1，我传入的index是0，小于当面元素个数，所以是合法的，于是就会返回elementData[0]，而这个值正是上面我们传入的值

elementData[size++] = e;

也就是我们添加进去的 1。

add(int index, E element)

在上面代码的背景下，我们执行以下代码

list.add(1,2); // 在index为1的位置添加一个元素 2

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++;
    }

这是另一个添加方法，传入下标和值，他会

在此列表中的指定位置插入指定的元素。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将一个元素添加到其索引中）。
参数：
index – 要插入指定元素的索引 element – 要插入的元素
抛出：
IndexOutOfBoundsException– 如果索引超出范围（索引 < 0 || 索引 > size（））

首先判断index下标的合法性，调用rangeCheckForAdd方法，传入index

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

因为我们上次执行了

list.add(1);

所以现在size = 1， 传入的index值为1，是合法的

然后在执行 ensureCapacityInternal方法，上面已经提到过这里不再赘述，但是因为上次我们直接将elementData的大小扩容到10，这次的size + 1只有2，所以这次我们是不需要扩容的
后面的内容就很简单了，参考上文即可。

未完待续…