标签：initial bounds this 删除元素 位置 void 集合 explicit argument
ArrayList是java中的线性结构的一种表示方法，在java中使用频率非常高，下面来一步一步分析其底层的实现。（JDK1.8）
一、构造函数
ArrayList的构造函数有三个，分别如下，
我们最常使用的的无参的构造函数，那么无参的构造函数是如何定义的那，
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
从上面看到无参构造函数，实际上是把elementData赋予了默认容量的一个数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA；
private static final Object[] 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); } }
从上面可以看出首先判断给定的初始容量是否大于0，如果大于0则使用此值生成Object数组。如果等于0则和无参构造函数是一样的。如果小于0则抛出异常。在实际开发中强烈建议使用带参数的构造函数（为什么下面说）。
最后一个构造函数如下，
public ArrayList(Collection<? extends E> 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 { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
从上面的代码中可以看出，把集合类c调用toArray方法，返回其数组赋给elementData，然后对elementData进行判断如果长度不为0，这判断elementData的类型是否为Object，如果不是则使用Object进行替换，统一处理成Obejct的类型，因为在java中所有的类的父类都是Object。
二、成员变量
在ArrayList中主要的成员变量有elementData和size，elementData代表底层ArrayList的存储结构，即ArrayList是用数组来保存数据的；size指的是ArrayList中元素的个数（和elementData的长度区分开）。其他的成员变量像默认的初始容量为10。ArrayList在使用无参构造函数的时候分配内存的时候采用了懒加载的模式，即使用new ArrayList的时候底层不会分配空间，在真正向ArrayList中放元素的时候才会真正初始化数组长度。
三、常用方法
1、set/add
set和add方法的不同之处在于set方法会返回被覆盖的值，而add则不会
set(int index,E element)
在index处插入元素element，其具体实现如下
public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; }
从上面的代码中可以看出，首先需要判断index是否合法，
private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
也就是说如果index大于ArrayList中元素的个数，则抛出异常，这里有个疑问ArrayList是使用数组存储，默认长度是10，那么向ArrayList中添加一个元素后其数组的长度为10，ArrayList中的元素为1，为什么不允许index大于size插入那。
在判断完index不大于size后，把要插入的元素放在数组中下标为index的位置，返回之前的元素。
add(E e)
向ArrayList中插入元素e返回boolean类型，表示是否插入成功。
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
可以看到首先要确保数组的容量，
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; }
判断elementData是否为空数组，如果是空数组返回初始容量和size+1两个数中大的那个，这里应该返回初始容量10。
下个方法是，
private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }
如果minCapacity大于数组的长度则进行扩容，
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); }
上面代码的意思是计算原数组的大小并且加上其右移1位（原大小的1.5倍）记为newCapacity。把要扩容到的大小和newCapacity比较，取两者中比较大的那个作为数组的容量。把原先的数组中的元素拷贝到新的数组中。
在回头来看add方法中的elementData[size++] = e;由于已经对数组进行了扩容，则可以把e放在size+1的位置上，返回true。
下面看add(int index,E e)
在index处插入e元素，
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的合法性
private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
然后确定底层数组的容量，判断是否需要扩容，如果不需要则把e插入到index的位置，这里不是使用的循环移动插入，而是进行了数组的分部分拷贝，把index前的元素和index后的元素进行拷贝，最后把e插入在index处，这种方式比循环移动插入要快（使用底层的拷贝技术）。
2、get方法
根据index取得ArrayList中的元素，
public E get(int index) { rangeCheck(index); return elementData(index); }
判断给定的index的值比较和size的大小，如果超过了size则抛出异常，否则返回其index处的值。
3、contains(Object o)方法
判断o是否在ArrayList中，由于ArrayList使用数组存储元素，所以它是允许存重复值的，而contains方法返回的则是o第一次出现的位置。
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; }
可以看到ArrayList中允许存null值，且可以存多个。
如果o不是null，则从头开始循环直到第一个为o的元素出现，返回其下标否则返回-1，最后根据indexOf的值大于0的返回true，否则false。
4、remove(int index)/remove(Object o)
从ArrayList中删除元素，可以按照索引和元素进行删除。按照元素删除仅会删除给定元素第一个的位置，其余不会删除。
remove(int index)
public E remove(int 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; }
首先依然是判断删除位置是否合法。如果合法则取得要删除索引位置的元素值（返回），因为要删除那么必然会进行数组的移动，即把删除位置后的数组向前移动，这里使用的是数组的拷贝。
remove(Object o)
按照元素进行删除，删除ArrayList中的第一个为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; }
这里仍然把null的情况单独处理，我们看不为null的情况的删除，使用size遍历整个数组，在数组中找到等于给定元素的下标，调用fastMove方法按照下标删除，只会把o第一次出现的位置上的元素删除，即重复的不会删除。
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 }
上面还是按照下标进行删除。
未完待续。
标签：initial bounds this 删除元素 位置 void 集合 explicit argument
原文地址：https://www.cnblogs.com/teach/p/11494895.html
