Java集合(二)ArrayList详解

（1）ArrayList简介

java.lang.Object
↳     java.util.AbstractCollection<E>
↳     java.util.AbstractList<E>
↳     java.util.ArrayList<E>

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

ArrayList动态数组，线程不安全，单线程中使用，多线程使用vector或者copyonwritearraylist

ArrayList继承AbstractList，实现了List，提供了添加删除修改遍历等

ArrayList实现了RandomAccess提供了随机访问的功能

ArrayList实现了Cloneable接口，即覆盖了函数clone,能够被克隆

ArrayList实现了Serializable接口，支持序列化，能通过序列化去传输



ArrayList中两个重要的对象：elementData 和 size。

1）elementDate:保存添加到ArrayList中的元素，是一个动态数组，我们通过构造函数可以指定初始化容量，默认容量10，如果需要增长容量，增长规则：新的容量=“(原始容量x3)/2 + 1”

2）size是动态数组的实际大小

（2）ArrayList重点源码分析

ArrayList源码分析(JDk6)

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
//保存ArrayList中数据的数组
private transient Object[] elementData;
//ArrayList的实际数据的数量
private int size;

//带容量大小的构造函数
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}

//默认构造函数，初始化容量值为10
public ArrayList() {
this(10);
}

//创建一个包含collection的ArrayList
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}

//当前容量值=实际元素个数
public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}

//确定ArrayList的容量，如果ArrayList的容量不足以容纳当前的全部元素，扩容。新的容量=（原始容量*3）/2+1
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

//返回当前容量值
public int size() {
return size;
}

//判断ArrayList是否为空
public boolean isEmpty() {
return size == 0;
}

//判断ArrayList是否包含某元素
public boolean contains(Object o) {
return indexOf(o) >= 0;
}

//正向查找是否包含某元素，可以看出ArrayList允许为空元素
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;
}

//反向查找是否包含某元素
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}

//克隆Arraylist
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}

//返回ArrayList的Object数组
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}

//返回ArrayList的模板数组，如果a的大小<ArrayList的个数，则新建T[],大小为ArrayList的大小，同时将ArrayList全部拷贝到T中
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}

//获取index位置的元素值
public E get(int index) {
RangeCheck(index);

return (E) elementData[index];
}

//设置index位置的元素值为E
public E set(int index, E element) {
RangeCheck(index);

E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}

//将元素e添加到ArrayList的最后
public boolean add(E e) {
ensureCapacity(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

//将元素E添加到ArrayList中的index位置
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);

ensureCapacity(size+1);  // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}

//移除index的某元素
public E remove(int index) {
RangeCheck(index);

modCount++;
E oldValue = (E) elementData[index];

int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work

return oldValue;
}

//移除ArrayList中的某个对象
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;
}

//快速移除某个位置元素，可以看到快速移除和普通移除的差别在于，不会检测index是否在ArrayList范围内，同时返回值为空
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; // Let gc do its work
}
//清除ArrayList中的全部元素，设置为null,说明允许重复
public void clear() {
modCount++;

// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;

size = 0;
}

//将集合C添加到ArrayList中
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew);  // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}

//将集合C添加到ArrayList中的某个Index位置之后
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);

Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew);  // Increments modCount

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

//移除区间范围的全部元素
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);

// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}

//检测index是否在ArrayList范围内
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}

//将ArrayList的容量，所有元素值都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();

// Write out array length
s.writeInt(elementData.length);

// Write out all elements in the proper order.
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);

if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}

}

//将流中的数据读出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();

// Read in array length and allocate array
int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];

// Read in all elements in the proper order.
for (int i=0; i<size; i++)
a[i] = s.readObject();
}
}

ArrayList源码分析(JDk8)

jdk8中的ArrayList在jdk6的基础上做了很大的改变，但是基本思路是一致的，同样有add,remove,addAll等方法。但是在扩容上做了很大的处理，保证了高效的分配空间，更加合理的处理了ArrayList为空的情况。这里我只列出改动比较大的方法，没有做出全部对比。

//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
//空数组常量
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组容量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元素的数组,transient无法自动序列化，数组内存储的元素其实是一个引用，单单序列化一个引用没有意义，反序列化后这些无法在指向原来的对象
transient Object[] elementData;
//数组中的元素个数
private int size;
//数组的最大上限
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//带容量大小的构造函数，当容量值为0分配空的数组常量，而JDK6中不会考虑数组为空的情况
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);
}
}
//空构造函数，不在是创建容量为10的，而是默认的空数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//创建一个包含collection的ArrayList
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;
}
}
//同jdk6中的方法
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//扩容
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;

if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//扩容检测，检测数组大小是否为0，为0，就默认扩容大小10；当数组大小大于当前数组大小时，才进行扩容
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

ensureExplicitCapacity(minCapacity);
}
//扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//扩容是真正调用的方法，扩容策略：新容量=原容量大小的1.5倍
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）remove方法中，为什么将数组对应的元素设置为Null？

在remove方法中已经将元素的数量-1了，ArrayList认为该对象已经被移除，应该被jvm回收。
但是对于jvm来说，该对象仍然保留在数组中。ArrayList持有这个对象的引用，
在JVM发生GC的时候，这个对象是不会被jvm回收，这样会造成内存泄露

（2）查找元素的方法中（比如indexOf），为什么需要对元素进行null值判断

判断对象是否相等，有两个方面。1.对象的存储地址 2.对象的值
==：判断两个对象的地址是否相等
equals:判断两个对象的值是否相等
对元素进行null值判断，应该是为了效率考虑，如果是Null的话直接比较地址，而是非空，通过equals比较

（3）jdk6和jdk8中对于ArrayList的扩容方式： 

JDK8：新容量 = 原容量*1.5（先进行大小检测，如果检测大小是0，那么扩容大小是10）
JDK6：新容量 = （原容量*3）/2+1

（3）ArrayList遍历方式

通过随机访问效率最高，使用迭代器效率最低 1）通过迭代器Iterator遍历

Iterator iter = list.iterator();
while(iter.hasNext()){
System.out.print(iter.next());
}

2）通过随机访问，通过索引值遍历

Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
value = (Integer)list.get(i);
}

3）for循环遍历

for(int i = 0; i < stringList.size();i++){
System.out.print(stringList.get(i));
}