目录
2.3.2，add(int index, E element)，在特定位置添加元素
2.3.6，indexOf(Object o)，查找某一个对象的下标索引
1，ArrayList的简介
- ArrayList的继承关系
- 为什么要先继承AbstractList，而让AbstractList先实现List<E>？而不是让ArrayList直接实现List<E>？
-
这里是有一个思想，接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类，如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来先一起实现了，减少重复代码。所以一般看到一个类上面还有一个抽象类，应该就是这个作用。
-
RandomAccess接口：这个是一个标记性接口，通过查看api文档，它的作用就是用来快速随机存取，有关效率的问题，
-
- ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
- ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
- ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在实现了该接口的话，那么使用普通的for循环来遍历，性能更高，例如arrayList。而没有实现该接口的话，使用Iterator来迭代，这样性能更高，例如linkedList。所以这个标记性只是为了让我们知道我们用什么样的方式去获取数据性能更好。
- 在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
- ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆，可以使用Object.Clone()方法了。
- ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。
- 和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
2，ArrayList的源码分析
- ArrayList在包中的定义：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}从上面的定义我们可以看出，ArrayList继承了AbstractList抽象类，实现了List，RandomAccess，Cloneable，java.io.Serializable等接口。其中RandomAccess是用来支持ArrayList进行随机访问的一个接口。
2.1，ArrayList的数据结构
说明：底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。
2.2，类中的属性
//版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认的初始容量
private static final int DEFAULT_CAPACITY = 10;
// 空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 缺省空对象数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 元素数组
transient Object[] elementData; // non-private to simplify nested class access
//数组中元素的个数
private int size;2.2，ArrayList的构造函数
//initialCapacity：标示初始的容量
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//在这里开辟一个对象数组，容量是自定义大小
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//EMPTY_ELEMENTDATA：是个空的Object[]， 将elementData初始化，elementData也是个Object[]
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造函数
public ArrayList() {
//DEFAULTCAPACITY_EMPTY_ELEMENTDATA：是个空的Object[]， 将elementData初始化，elementData也是个Object[]
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//构造一个数组，并且把特定集合中元素添加进来
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)
//每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么久需要使用ArrayList中的方法去改造一下。
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}- 总结：arrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。
2.3，核心方法
2.3.1，add()方法
//在列表的末尾添加一个元素
public boolean add(E e) {
//确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下，就在这个方法中去判断是否数组.length是否够用了。
ensureCapacityInternal(size + 1); // Increments modCount!!
//把元素添加到末尾,size加1
elementData[size++] = e;
return true;
}- ensureCapacityInternal（num）:确定内部容量的方法。
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) { //看，判断初始化的elementData是不是空的数组，也就是没有长度
//因为如果是空的话，minCapacity=size+1；其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认大小，但是带这里，还没有真正的初始化这个elementData的大小。
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//确认实际的容量，上面只是将minCapacity=10，这个方法就是真正的判断elementData是否够用
ensureExplicitCapacity(minCapacity);
}- ensureExplicitCapacity(int minCapacity)：确认数组的实际容量。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。这里有的同学就会模糊minCapacity到底是什么呢，这里给你们分析一下
/*第一种情况：由于elementData初始化时是空的数组，那么第一次add的时候，minCapacity=size+1；也就minCapacity=1，在上一个方法(确定内部容量ensureCapacityInternal)就会判断出是空的数组，就会给
将minCapacity=10，到这一步为止，还没有改变elementData的大小。
第二种情况：elementData不是空的数组了，那么在add的时候，minCapacity=size+1；也就是minCapacity代表着elementData中增加之后的实际数据个数，拿着它判断elementData的length是否够用，如果length
不够用，那么肯定要扩大容量，不然增加的这个元素就会溢出。
*/
if (minCapacity - elementData.length > 0)
//arrayList能自动扩展大小的关键方法就在这里了
grow(minCapacity);
}- grow()方法：给数组扩容。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; //将扩充前的elementData大小给oldCapacity
int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity就是1.5倍的oldCapacity
if (newCapacity - minCapacity < 0)//这句话就是适应于elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10.前面的工作都是准备工作。
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//新的容量大小已经确定好了，就copy数组，改变容量大小咯。
elementData = Arrays.copyOf(elementData, newCapacity);
}- hugeCapacity(int minCapacity)
//这个就是上面用到的方法，很简单，就是用来赋最大值。
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。
//Integer.MAX_VALUE:2147483647 MAX_ARRAY_SIZE：2147483639 也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}2.3.2，add(int index, E element)，在特定位置添加元素
public void add(int index, E element) {
//检查插入的位置是否是合法的
rangeCheckForAdd(index);
//插入一个元素，数组长度就需要增大一个，用来判断size+1的数组是否能放得下
ensureCapacityInternal(size + 1); // Increments modCount!!
//这个方法就是用来在插入元素之后，要将index之后的元素都往后移一位，
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//在目标位置插入元素
elementData[index] = element;
size++;
}- rangeCheckForAdd(index)：检查插入范围是否是合法的。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}-
System.arraycopy(elementData, index, elementData, index + 1,size - index);将size - index个元素从Index+1位置处后移一个元素位置。 -
正常情况下会扩容1.5倍，特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。
-
当我们调用add方法时，实际上的函数调用如下：
说明：程序调用add，实际上还会进行一系列调用，可能会调用到grow，grow可能会调用hugeCapacity。
public class TestArrayList {
public static void main(String[] args) {
List arrayList=new ArrayList();
arrayList.add(32);
}
}调用的是无参构造函数。数组默认初始化是10。
初始化时候指定数组容量的大小：
public class TestArrayList {
public static void main(String[] args) {
List arrayList=new ArrayList(6);
arrayList.add(32);
}
}
说明：我们可以知道，在调用add方法之前，elementData的大小已经为6，之后再进行传递，不会进行扩容处理。
2.3.3，remove(int)方法
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);
//size的大小-1，将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}2.3.4，remove(Object)
这个方法可以看出来，arrayList是可以存放null值。
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;
}- fastRemove(int index)的实现几乎和remove(index)一样。
2.3.5，clear()方法
将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉，所以叫clear
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
//将每一个对象都设置为null,以便于垃圾回收器去回收
size = 0;
}- 总结：：remove函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用。
2.3.6，indexOf(Object o)，查找某一个对象的下标索引
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;
}
2.3.7，toArray()函数
当我们调用ArrayList中的 toArray()，可能遇到过抛出“java.lang.ClassCastException”异常的情况。ArrayList提供了两个toArray()函数：
Object[] toArray()
<T> T[] toArray(T[] contents)- 调用 toArray() 函数会抛出“java.lang.ClassCastException”异常，但是调用 toArray(T[] contents) 能正常返回 T[]。
- toArray() 会抛出异常是因为 toArray() 返回的是 Object[] 数组，将 Object[] 转换为其它类型(如如，将Object[]转换为的Integer[])则会抛出“java.lang.ClassCastException”异常，因为Java不支持向下转型。具体的可以参考前面ArrayList.java的源码介绍部分的toArray()。
- 解决该问题的办法是调用 <T> T[] toArray(T[] contents) ， 而不是 Object[] toArray()。
- 调用 toArray(T[] contents) 返回T[]的可以通过以下几种方式实现。
public class TestArrayList {
public static void main(String[] args) {
ArrayList arrayList=new ArrayList(5);
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5);
// 第一种方式
Integer []arr=new Integer[5];
// 把arrayList中的内容复制到数组中
arrayList.toArray(arr);
// 第二种方式
Integer []arr01=(Integer [])arrayList.toArray(new Integer[0]);
// System.out.println(Arrays.toString(arr01));
}
}3，ArrayList的遍历方式
3.1，通过迭代器进行遍历
public class TestArrayList {
public static void main(String[] args) {
List arrayList=new ArrayList(6);
arrayList.add(32);
arrayList.add(43);
arrayList.add(54);
arrayList.add(21);
// 获取迭代器
Iterator iterator=arrayList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
3.2，通过下标索引进行访问
由于ArrayList实现了RandmoAccess接口，所以可以随机访问。
public class TestArrayList {
public static void main(String[] args) {
List arrayList=new ArrayList(6);
arrayList.add(32);
arrayList.add(43);
arrayList.add(54);
arrayList.add(21);
for(int i=0;i<arrayList.size();i++){
System.out.println(arrayList.get(i));
}
}
}3.3，通过增强的for循环进行遍历
public class TestArrayList {
public static void main(String[] args) {
List <Integer>arrayList=new ArrayList(6);
arrayList.add(32);
arrayList.add(43);
arrayList.add(54);
arrayList.add(21);
for(Integer num:arrayList){
System.out.println(num);
}
}
}
3.4，小结
- ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10，否则使用指定的容量。
- ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
- ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
- arrayList可以存放null。
- arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法。
- arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。
- arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。
- arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。
参考资料：
[1] https://www.cnblogs.com/skywang12345/p/3308556.html
119
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
