ArrayList是java核心容器List下的一个子类,底层使用数组实现,可以包含重复元素,允许null元素存在,可以通过指定下标快速获得元素值。下面分为三块内容:成员变量、构造方法、核心方法。
文章目录
成员变量
elementData
ArrayList包含的元素存储在该数组中,该数组的长度代表了ArrayList的容量(注意和size不同,size代表的是ArrayList中存储的元素个数)。可以看到,ArrayList的底层是用数组实现的。
若ArrayList当前实例为空(size为0),且elementData与DEFAULTCAPACITY_EMPTY_ELEMENTDATA相等时,在该列表中加入到一个元素就将其扩展为默认容量(DEFAULT_CAPACITY)的大小。
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData; // non-private to simplify nested class access
size
//数组的大小(数组中元素的数量)
private int size;
DEFAULT_CAPACITY
//默认的初始化容量为10。
private static final int DEFAULT_CAPACITY = 10;
EMPTY_ELEMENTDATA
//一个空的实例数组
private static final Object[] EMPTY_ELEMENTDATA = {};
DEFAULTCAPACITY_EMPTY_ELEMENTDATA
这个成员变量看起来和EMPTY_ELEMENTDATA
没有任何区别,但其实我们在看构造方法时就可以发现,这个变量和EMPTY_ELEMENTDATA
是用来区分同样都是空数组时,List<> list = new ArrayList<>()
和List<> list = new ArrayList<>(0)
等不同的构造方法在加入第一个元素时膨胀elementData
数组的区别。
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
//一个空的实例数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
构造方法
ArrayList共有三个构造方法,分别是无参数(默认大小为0)、一个int型参数(指定容量大小)以及一个Collection参数(将其他容器中的内容复制到ArrayList中)。
ArrayList(int initialCapacity)
创建一个指定大小的List,若指定大小为0,则使elementData
等于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);
}
}
ArrayList()
创建一个空的List,此时elementData
等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA
。
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ArrayList(Collection<? extends E> c)
创建一个List,List中的元素为集合c中的元素。
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;
}
}
核心方法
ArrayList最常用的方法包括获取某个元素的index、插入一个元素、删除一个元素、获取index位置的元素、清空数组等。
indexof(时间复杂度O(n))
时间复杂度为O(n)。遍历数组元素,找到元素的下标位置,若未出现,则返回-1。indexOf
方法是从前往后遍历,lastIndexOf
是从后往前遍历。从代码中可以看出,ArrayList中允许元素为null。
//获取指定元素第一次出现的index
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;
}
//获取指定元素最后一次出现的index
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;
}
clone
获得一个当前数组的浅拷贝。拷贝了一个新的数组,但数组中元素本身并没有被拷贝。
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) 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(e);
}
}
get(时间复杂度O(1))
获取指定下标的元素。时间复杂度O(1)。
首先判断index的值是否合法,不合法直接抛出异常,合法返回elementData
中的对应下标的元素。
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
set(时间复杂度O(1))
替换指定index的元素值。时间复杂度O(1)。返回index原本的值。
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
add(可能需要扩容,时间复杂度O(1)/O(n))
在指定index或者数组尾部插入元素。
在尾部插入首先保证数组容量够大(size+1),接着在最后位置插入一个元素。时间复杂度O(1)。
在指定index插入元素也需要保证数组容量够大,再将原数组index后的元素都向后移一位,再将index位置的元素改为参数中的元素值。时间复杂度为O(n)。
//数组尾部插入元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//数组index位置处插入元素
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
因为插入元素可能会有数组容量不够大的情况,涉及到数组的扩容操作。
扩容操作就是把数组容量增加原来容量的一半。代码下面贴出来了。
//确保数组的容量大于等于minCapacity
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//如果数组初始化方式为list = new ArrayList(),在插入第一个元素时,将数组容量设为默认大小--10。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
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);
//如果新的容量还是不够大,则将容量改为minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新的容量比最大容量更大,将容量扩展为Integer.MAX_VALUE。
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//扩展数组容量为newCapacity
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
remove(时间复杂度O(n))
删除指定index的元素或是删除某个指定的元素。
删除指定index的元素就是将指定index后的元素都往前移一位,并把数组最后一位的元素置为null(垃圾回收器会自动回收该块内存),size减1,并返回被删除的那个元素。时间复杂度为O(n)。
删除指定元素就是在数组中遍历,找到第一个该元素,删除并返回true,否则返回false。这里调用的fastRemove(index)
函数与remove(index)
类似,省去了边界检查等操作。时间复杂度为O(n)。
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; // clear to let GC do its work
return oldValue;
}
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;
}
总结
ArrayList底层使用数组实现,根据下标获取元素很快,但要在指定位置插入或者删除操作需要移动后面所有元素,较慢。且ArrayList是线程不安全的,当有多个线程同时修改时,会出现问题,可考虑用Vector代替(Vector在方法中使用了synchronized关键字修饰)。