系列文章目录
提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
- 第一章 String
- 第二章 Integer
- 第三章 ArrayList
- 第四章 LinkedList
- 第五章 HashMap
- 第六章 ConcurrentHashMap
- 第七章 AbstractQueuedSynchronizer（AQS)
- 第八章 ReentrantLock
文章目录
前言
提示：这里可以添加本文要记录的大概内容：
ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
提示：以下是本篇文章正文内容，下面案例可供参考
一、源码分析
接口和变量：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
//指定ArrayList容量为0时返回该数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//当没有指定ArrayList容量时返回该数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//保存添加到ArrayList中的元素（ArrayList的底层其实就是一个数组）
transient Object[] elementData;
//ArrayList中元素数量
private int size;
.....
}
在这个源码中可以看出：
- ArrayList 底层使用一个 Object类型的数组来保存数据
- ArrayList 大小默认为0
ArrayList 使用 elementData保存数据，因此称为动态数组，使用 transient修饰。
transient代表 elementData无法序列化
构造函数
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // {}
}
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);
}
}
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();// 进行数组转换
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) { // 判断类型
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);// 跳转到下边copyOf方法
}
} else {
// replace with empty array.
//如果传入的c长度为0，则替换成空数组
elementData = EMPTY_ELEMENTDATA;
}
}
----------
// original——>原数组 newLength——>要复制的长度 newType——>新类型
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
// 判断是否 Object数据类型
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//getComponentType()——>本地方法，返回数组内的元素类型，不是数组时，返回null
//Array.newInstance——>创建一个类型与newType一样，长度为newLength的数组
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
----------
// System.arraycopy()
// src - 源数组。
// srcPos – 源数组中的起始位置。
// dest - 目标数组。
// destPos – 目标数据中的起始位置。
// length – 要复制的数组元素的数量。
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
----------
byte[] srcBytes = new byte[]{2,4,0,0,0,0,0,10,15,50};//原数组
byte[] destBytes = new byte[5]; //目标数组
System.arrayCopy(srcBytes,0,destBytes ,0,5) // 运行结果 2,4，0,0，0
添加元素add
public boolean add(E e) {
//判断ArrayList是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/*判断是否需要扩容——> minCapacity是集合需要的最小容量*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/*返回添加元素后的容量大小*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//首次添加元素时，返回 minCapacity > 10 ? minCapacity : 10 （首次可能使用addAll方法添加大量元素
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return 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;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容为原来的1.5倍
if (newCapacity - minCapacity < 0)//如果扩容后还是小于最小容量，则设置minCapacity为容量大小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//调用Arrays.copyOf生成新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
获取、设置元素
/*
* 获取index索引对象
*/
public E get(int index) {
rangeCheck(index);//参数校验
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
/*
* 设置index索引对象
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
删除元素
/*
* 删除index索引对象
*/
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);
elementData[--size] = null; //设为null让JVM回收
return oldValue;//返回旧数据
}
遍历比较然后删除。
/*
* 删除给定Object对象
*/
public boolean remove(Object o) {
if (o == null) {//删除null对象-->ArrayList可以存放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++;//修改次数+1
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,numMoved);
elementData[--size] = null; // clear to let GC do its work
}
删除元素不会减小容量，若希望减少容量则调用trimToSize(),比较简单。
/*
* 修改数组尺寸
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
总结
构造函数（初始化）、add 添加 、remove 删除 、get 获取 、set 设置 的分析。