标签：缩小 clone random 判断 比较 不同 com 大于 添加元素
JDK1.8源码学习-ArrayList
目录
一、ArrayList简介
为了弥补普通数组无法自动扩容的不足，Java提供了集合类，其中ArrayList对数组进行了封装，使其可以自动的扩容或缩小长度，相当于动态数组。
ArrayList封装了一个动态的可以重新分配的Object[]数组，其中每一个类的对象都有一个capacity属性，表示了它们所封装的Object[]数组的长度，当向ArrayList中添加元素的时候，该属性会自动的添加。如果想要添加大量元素的时候，可以使用ensureCapacity方法一次性增加capacity,减少数组的重新分配次数，提高效率。
二、ArrayList工作原理和数据结构
对于数组，这里就不进行过多叙述了。 想要说明的是ArrayList集合中底层数组元素的类型为Objec类型，即可以存放所有类型的数据。我们对ArrayList类的实例的操作，也都是基于数组的。
三、ArrayList源码分析
3.1、继承关系分析
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList继承自AbstractList,实现了List、RandomAccess、Cloneable、Serializable接口，其中List中定义了一些基本的增删查改的功能,实现RandomAccess接口则具有随机读写的功能，实现了Cloneable接口，可以被克隆，实现了Serializable可以使ArrayList实现序列化。
3.2、成员变量分析
//定义的序列化id，主要是为了标识不同版本的兼容性 private static final long serialVersionUID = 8683452581122892189L; //默认的数组存储容量为 10 private static final int DEFAULT_CAPACITY = 10; //当指定数组的容量为0的时候使用这个变量赋值，空对象数组 private static final Object[] EMPTY_ELEMENTDATA = {}; //默认的实例化的时候使用此变量赋值，空对象数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //真正存放数据的对象数组，并不被序列化 （前面加有transient关键字） transient Object[] elementData; //数组中的真实元素个数它小于或等于elementData.length private int size; //数组中最大存放元素的个数 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
3.3、构造函数分析
3.3.1无参构造函数
ArrayList无参构造函数，默认初始化容量是10。
/** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; //默认值：10 }
在这里注释上说明构造一个容量为10的空的list，但是并没有看到数组的容量变为10，而是一个空的数组，实际上当有元素被加入(add方法)的时候，才会被初始化为10的数组。
3.3.2传入初始化容量构造函数
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); } }
创建一个initialCapacity大小的数组。
3.3.3传入初始化元素的构造函数
public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { //判断引用的数组类型，并将引用转换成Object数组引用 if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { //替换为空数组 this.elementData = EMPTY_ELEMENTDATA; } }
传入一个集合类(Collection的子类即可)，转为list。
总结：可以看出ArrayList的内部存储结构就是一个Object类型的数组，因此它可以放任意类型的元素。在构造ArrayList的时候，如果传入初始大小，那么它将新建一个指定容量的Object数组，如果不设置初始大小，那么它将不会分配内存空间而是使用对象数组，在实际要放入元素的时候再进行内存分配。
3.4、add()方法分析
ArrayList中提供了四种方式的添加：1.直接添加；2.指定位置添加；3.添加全部；4.在指定位置添加全部。
1.直接添加
public boolean add(E e) { //添加前先检查是否需要拓展数组, 此时数组长度最小为size+1 ensureCapacityInternal(size + 1); //将元素添加到数组末尾 elementData[size++] = e; return true; }
add(E e)调用涉及的方法：
1.private void ensureCapacityInternal(int minCapacity) { //判断数组是不是一个长度为0的空数组 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //如果是的话则给容量赋值为默认的容量大小10 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } 2. private void ensureExplicitCapacity(int minCapacity) { modCount++; //判断当前容量是否大于数组当前的长度 if (minCapacity - elementData.length > 0) //如果数组容量过小则进行扩容 grow(minCapacity); } 3.private void grow(int minCapacity) { int oldCapacity = elementData.length; //扩容的长度是增加了原来数组的一半大小 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //判断是否达到了数组扩容的上限 if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); //把旧数组里面的数据拷贝到新数组中 elementData = Arrays.copyOf(elementData, newCapacity); } 4.private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) throw new OutOfMemoryError(); //如果minCapacity还大于MAX_ARRAY_SIZE,那么就将Integer.MAX_VALUE返回,反之将MAX_ARRAY_SIZE返回。 //因为maxCapacity是三倍的minCapacity,可能扩充的太大了,就用minCapacity来判断了。 return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
2.指定位置添加
public void add(int index, E element) { //插入位置范围检查 rangeCheckForAdd(index); //检查是否需要扩容 ensureCapacityInternal(size + 1); //挪动插入位置后面的元素（将elementData中的元素从index开始，拷贝到index+1的位置，拷贝size-index个元素） System.arraycopy(elementData, index, elementData, index + 1, size - index); //在要插入的位置赋上新值 elementData[index] = element; size++; }
在指定位置进行添加，必然会影响到该位置的元素以及后续元素，因为是数组结构，所以只能进行元素的后移了，同时要首先检查入参的元素的位置(index)是否在范围内。
其中System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)方法中的参数的含义：src(原数组)、srcPos(从原数组的起始位置开始)、dest(目标数组)、destPos(目标数组的起始位置)、length（要copy的数组的长度）
3.添加一个集合中的全部元素
public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; //检查是否需要扩容 ensureCapacityInternal(size + numNew); //进行元素拷贝 System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; }
4.在指定位置上添加一个集合中的全部元素
public boolean addAll(int index, Collection<? extends E> c) { //插入位置范围检查 rangeCheckForAdd(index); Object[] a = c.toArray(); int numNew = a.length; //检查是否需要扩容 ensureCapacityInternal(size + numNew); //复制元素的个数 int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; }
3.5、set()方法分析
修改的方法比较简单，就是给数组的下标重新赋值。
public E set(int index, E element) { //index不能大于size rangeCheck(index); E oldValue = elementData(index); //替换成新元素 elementData[index] = element; return oldValue; }
确保set的位置(index)小于当前数组的长度(size)并且大于0，获取指定位置（index）元素，然后放到oldValue中存放，将需要设置的元素放到指定位置(index)上。
3.6、remove()方法分析
1. E remove(int index):根据下标进行删除
public E remove(int index) { // 检查下标是否越界 rangeCheck(index); modCount++; E oldValue = elementData(index); //最后 -1 是为了数组下标不越界 int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; //置空引用，让GC进行回收 return oldValue; }
2.boolean remove(Object o):根据传入对象进行删除
// 删除成功返回true, 失败false 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; //置空引用,让GC进行回收 }
3. boolean removeAll(Collection<?> c):根据传入集合进行删除
public boolean removeAll(Collection<?> c) { 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++) // 如果complement为false, 则c集合包含本集合中的元素, 则不进行操作, 这就是保留不属于c集合中的所有元素. 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; } 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; }
如果传入的集合c中包含本集合中的元素，则对元素进行处理，把匹配的元素（c.contains(elementData[r])==complement）进行保留，不需要保留的下标置为null，其中利用complement属性，来决定含有的元素是删除还是保留。
3.7、get()方法分析
public E get(int index) { //检查是否越界 rangeCheck(index); //返回指定位置上的元素 return elementData(index); }
四、ArrayList总结
1、ArrayList底层实现是基于数组的，因此对指定下标的查找和修改比较快，但是删除和插入操作比较慢。
2、构造ArrayList的时候尽量指定容量，减少扩容所带来的数组复制操作，如果不知道大小可以采用默认值10。
3、每次添加元素之前会检查是否需要扩容，每次扩容都是增加原有容量的一半。
4、ArrayList中的所有的方法都没有进行同步，因此它不是线程安全的。
5、在查找给定元素索引值等方法中，源码都将该元素的值分为null和不为null两种情况进行处理，ArrayList中允许元素为null。
标签：缩小 clone random 判断 比较 不同 com 大于 添加元素
原文地址：https://www.cnblogs.com/liudblog/p/10764099.html
