数组是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。 总的来说，数组具有以下特点：
数组可以是一维数组、二维数组或多维数组。数值数组元素的默认值为 0，而引用元素的默认值为 null。交错数组是数组的数组，因此，它的元素是引用类型，初始化为 null。交错数组元素的维度和大小可以不同。数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。数组元素可以是任何类型，包括数组类型。数组类型是从抽象基类 Array 派生的引用类型。集合（只能存储对象，对象类型可以不一样）的长度课表，可以在多数情况下使用
Collection接口是集合类的跟接口，Java中没有提供这个接口的实现类。但是却让其他被继承产生了两个接口，就是Set和List。Set不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了岸所以访问的方式。
Map是Java.util包中的另一个接口，他和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含key-value对，Map不能包含重复的key，单可以包含相同的value。（如果有相同的key，后者的key的值会覆盖前者的值）。
Iterator所以的集合类，都实现了Iterator接口，这是一个遍历集合中元素德尔接口，主要包含一下三张方法：
1、hasNext()是否还有下一个元素。2、next()返回下一个元素。3、remove()删除当前元素
List里存放的对象是有序的，同时可以重复。List关注的是索引，拥有一系列和索引相关的方法，查询速度魁岸。因为往list集合里插入或删除数据市，会伴随后面数据的移动。查询快，增删慢;线程不安全，效率高
ArrayList是基于数组的，在初始化ArrayList时，会构建空数组（Object[] elementDate={}）。ArrayList是一个无序的，他是按照添加的先后顺序排列，当然，他也提供了sort方法，如果需要对ArrayList进行排序，只需要调用这个方法。
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
实现了RandomAccess接口，因此支持随机访问，这是理所当然的，因为ArrayList是基于数组实现的
ArrayList内部通过一个Object数组来存储数据
transient Object[] elementData;
ArrayList使用size变量来表示实际存储的元素个数
private int size;
ArrayList有以下三个构造方法
// 根据initialCapacity来创建具有指定初始容量的ArrayList public ArrayList(int initialCapacity) // 创建一个默认的ArrayList public ArrayList() // 根据其他集合来创建ArrayList public ArrayList(Collection<? extends E> c)
我们来详细看一下这三个构造方法：
public ArrayList(int initialCapacity) { // 创建指定初始容量的ArrayList if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } // 初始化容量指定为0，则用EMPTY_ELEMENTDATA数组 else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } // 否则，抛出IllegalArgumentException异常 else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }EMPTY_ELEMENTDATA定义如下（即长度为0的Object数组）：
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList() { // 默认ArrayList的内部数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }DEFAULTCAPACITY_EMPTY_ELEMENTDATA声明如下：
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA是一样的，都是定义为了长度为0的Object数组，那它们有什么区别呢？它们两个的主要区别在于添加第一个元素时，若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA ，则程序会将其扩充为容量为DEFAULT_CAPACITY的数组，DEFAULT_CAPACITY定义为10，即通过默认的构造方法创建的ArrayList的初始容量是10。我们后面会详细介绍数组的扩容。
public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // 通过反射获取数组类型，判定c.toArray类型是否为Object[]类型 if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // 若c为空，则内部数组为EMPTY_ELEMENTDATA this.elementData = EMPTY_ELEMENTDATA; } }我们下面主要来看下ArrayList的add和remove方法
remove方法在ArrayList中同样有两种实现方式：
// 根据index下标删除元素
public E remove(int index)
// 根据元素删除
public boolean remove(Object o)
remove(int index)方法源码如下：
public E remove(int index) { // 下标合法性检验 rangeCheck(index); // 修改次数加1 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; }这里需要注意一点的就是rangeCheck(int)方法：
private void rangeCheck(int index) { // 若index下标超出size，则抛出IndexOutOfBoundsException异常 if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }这里只判断了index超出了size，而不需要判断index为负数的情况，这是为什么呢？
因为该方法总是在访问数组之前被调用，在访问数组时，会对下标为负数进行判断，如果index为负数，则会抛出ArrayIndexOutOfBoundsException异常，所以在这里就没有必要判断了，避免冗余。
remove(Object o)方法源码如下：
public boolean remove(Object o) { // 若删除的元素为null if (o == null) { for (int index = 0; index < size; index++) // 若数组元素为null，则调用fastRemove方法快速删除 if (elementData[index] == null) { fastRemove(index); return true; } } // 若删除的元素不为null else { for (int index = 0; index < size; index++) // 找到要删除的元素，调用fastRemove方法快速删除 if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; }ArrayList删除元素时，是分为元素为null和不为null两种方式来判断的，这也说明ArrayList允许添加null元素；同时，如果这个元素在ArrayList中存在多个，则只会删除最先出现的那个。
删除元素，采用了fastRemove(int)方法来快速删除：
private void fastRemove(int index) { // 修改次数加1 modCount++; // 计算需要移动的元素数目 int numMoved = size - index - 1; // 将index之后的元素向前移动一位 if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); // 将数组最后一位置为null elementData[--size] = null; // clear to let GC do its work }ArrayList有两个重载的add方法
// 在数组elementData尾部添加一个元素
public boolean add(E e)
// 在数组elementData指定位置index处添加元素
public void add(int index, E element)
add（E e）方法的源码如下
// 在数组elementData尾部添加一个元素 public boolean add(E e) { // 容量大小判断 ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }该方法首先要判断elementData数组的容量是否能过容纳新的元素，若不能，则需要进行扩容操作，然后将元素e放置在数据组的siez位置。
ensureCapacityInternal(int)方法源码如下：
private void ensureCapacityInternal(int minCapacity) { // 若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // minCapacity = max(10, minCapacity) minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } // 针对数组最小容量，决定是否扩容 ensureExplicitCapacity(minCapacity); }前面所说到的DEFAULTCAPACITY_EMPTY_ELEMENTDATA，在这里就起到作用了，若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则会将数组的最小容量设置为10。然后通过ensureExplicitCapacity(int)方法来判断是否要扩容：
private void ensureExplicitCapacity(int minCapacity) { // 增加修改次数 modCount++; // overflow-conscious code // 增加元素后，ArrayList中要存储的元素个数为minCapacity // 若此时minCapacity > elementData原始的容量，则要按照minCapacity进行扩容 if (minCapacity - elementData.length > 0) grow(minCapacity); }扩容的最终操作是通过grow(int)方法来实现的：
private void grow(int minCapacity) { // overflow-conscious code // 获取elementData的原始容量 int oldCapacity = elementData.length; // 计算新的容量 // 若原数组长度为偶数，那么新数组长度就恰好是原数组长度的1.5倍 // 若原数组长度为奇数，那么新数组长度就恰好是原数组长度的1.5倍 - 1 int newCapacity = oldCapacity + (oldCapacity >> 1); // 若按照1.5倍进行扩容后，capacity仍然比实际需要的小，则新容量更改为实际需要的大小，即minCapacity if (newCapacity - minCapacity < 0) newCapacity = minCapacity; // 如果新数组的长度比虚拟机能够提供给数组的最大存储空间大，则将新数组长度更改为最大正数：Integer.MAX_VALUE if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: // 按照新的容量newCapacity创建一个新数组，然后再将原数组中的内容copy到新数组中 elementData = Arrays.copyOf(elementData, newCapacity); }扩容函数整体比较好理解，需要注意的是，若新容量过大，则会通过hugeCapacity(int)方法来进行容量判断：
private static int hugeCapacity(int minCapacity) { // minCapacity < 0则表明数组容量已经超过了虚拟机所能表示的最大容量，抛出OutOfMemoryError if (minCapacity < 0) // overflow throw new OutOfMemoryError(); // 否则，若minCapacity > MAX_ARRAY_SIZE，则数组容量为Integer.MAX_VALUE，否则为MAX_ARRAY_SIZE（Integer.MAX_VALUE - 8） return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }add(int index, E element)方法源码如下：
public void add(int index, E element) { // 判断下标index的合法性 rangeCheckForAdd(index); // 数组容量判断 ensureCapacityInternal(size + 1); // Increments modCount!! // 数组拷贝，将index到末尾的元素拷贝到index + 1到末尾的位置，将index的位置留出来 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }该方法与add(E e)方法类似，只是元素的插入位置不同，该方法需要调用rangeCheckForAdd(int)方法来对index进行合法检验：
private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }若index下标不合法，则抛出IndexOutOfBoundsException异常。
trimToSize()源码如下：
public void trimToSize() { // 修改次数加1 modCount++; // trim if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } }该方法的主要工作就是将数组容量修改为size大小，若size为0，则将数组设置为EMPTY_ELEMENTDATA，否则，通过Arrays.copyOf方法来创建新的数组。
该方法的主要存在意义就是：如果capacity被分配过大，那么可以通过这个方法，将ArrayList实例的capacity的大小修改为数组存储元素的个数，从而缩减ArrayList的存储空间。
该方法有可能会抛出java.lang.ClassCastException异常，如果直接用向下转型的方法，将整个ArrayList集合转变为指定类型的Array数组，便会抛出该异常，而如果转化为Array数组时不向下转型，而是将每个元素向下转型，则不会抛出该异常，显然对数组中的元素一个个进行向下转型，效率不高，且不太方便。
该方法可以直接将ArrayList转换得到的Array进行整体向下转型（转型其实是在该方法的源码中实现的），且从该方法的源码中可以看出，参数a的大小不足时，内部会调用Arrays.copyOf方法，该方法内部创建一个新的数组返回，因此对该方法的常用形式如下：
public static Integer[] toArray(ArrayList<Integer> v) { Integer[] array = (Integer[])v.toArray(new Integer[0]); return array; }
