简介
ArrayList是一个数组队列，相当于一个动态数组。与Java中的数组相比，它的容量能动态增长，它是通过Arrays.copyof()的方式实现数组的增长（即扩容），这个后面我们会具体谈到。
ArrayList继承了AbstractList，实现了List。提供了相关的添加、删除、修改、遍历等功能。
ArrayList实现了RandomAccess接口，即提供了随机访问功能。
ArrayList中的操作是线程不安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
构造函数
（1）先看JDK1.8下的：
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
//默认构造函数
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/** capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的 一半。
*/
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);
}
}
// 创建一个包含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;
}
}（2）再看JDK1.6下的：
// ArrayList构造函数。默认容量是10。
public ArrayList() {
this(10);
}
// ArrayList带容量大小的构造函数。
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 新建一个数组
this.elementData = new Object[initialCapacity];
}
// 创建一个包含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);
}对比一下可以看出，ArrayList的不带参的构造函数在JDK1.6和JDK1.8还是有区别：
JDK1.6时，ArrayList的不带参的构造函数，指定了初始容量，初始容量为10；
JDK1.8时，ArrayList的不带参的构造函数，未指定初始容量，而是指定了一个空数组：Object[] elementData={}；
添加函数
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
//添加
public boolean add(E e) {
//在添加元素之前，先保证数组的容量足够，如果不足够就进行扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//在保证容量后，把要添加的元素当前最大索引+1处
elementData[size++] = e;
return true;
}
//确保容量
private void ensureCapacityInternal(int minCapacity) {
//如果当前数组容量为空，则比较最小需要的容量和默认容量10之间的最大值，作为最小需要的容量
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);//扩容
}
//扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;//获取当前数组的容量
//扩容后新数组的容量=当前数组容量+当前数组容量右移1位=1.5倍*当前数组容量
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);//通过Arrays.copyof进行扩容
}
下面我们来看一看扩容调用的方法：Arrays类里面的copyof方法
//数组的复制
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}由此可见Arrays.copyof最终是调用了System类下的System.arraycopy方法，而arraycopy方法是一个native JNI方法，具体实现在C/C++,在这里就不过多研究了：
@FastNative
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);在这里需要指出的一点是：在JDK1.6的扩容函数里面：
public void ensureCapacity(int minCapacity) {
// 将“修改统计数”+1
modCount++;
int oldCapacity = elementData.length;
// 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}JDK1.6中：int newCapacity = (oldCapacity * 3)/2 + 1; 和
JDK1.8中：int newCapacity = oldCapacity + (oldCapacity >> 1);
略有不同，一个是通过乘3除以2+1，一个是通过右移，不过都是扩容为原来的1.5倍。
ArrayList遍历方式
（1）通过迭代器遍历。即通过Iterator去遍历：
Integer value=null;
Iterator iter=list.iterator();
while(iter.hasNext()){
value=(Integer)iter.next();
}(2)随机访问，通过索引值去遍历：
Integer value=null;
int size=list.size();
for(int i=0;i<size;i++){
value=(Integer)list.get(i);
}（3）for-each循环遍历
Integer value=null;
for(Integer integ:list){
value=integ;
}经过对比分析：这三种遍历方式，使用随机访问效率最高，使用迭代器的效率最低。
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不支持向下转型。
解决该问题的办法是调用<T> T[] toArray(T[] contents),而不是Object[] toArray().
// toArray(T[] contents)调用方式一
public static Integer[] vectorToArray1(ArrayList<Integer> v) {
Integer[] newText = new Integer[v.size()];
v.toArray(newText);
return newText;
}
// toArray(T[] contents)调用方式二。最常用！
public static Integer[] vectorToArray2(ArrayList<Integer> v) {
Integer[] newText = (Integer[])v.toArray(new Integer[0]);
return newText;
}
// toArray(T[] contents)调用方式三
public static Integer[] vectorToArray3(ArrayList<Integer> v) {
Integer[] newText = new Integer[v.size()];
Integer[] newStrings = (Integer[])v.toArray(newText);
return newStrings;
}好了，到这里关于ArrayList已经做完了一个简单的基本介绍。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
