List接口继承自Collction(单列集合)接口,而ArrayList是List接口的一个重要实现类,当学习了ArrayList后再看其他实现类,如Vector和LinkedList(前者可以看作ArrayList的线程安全版,后者是ArrayList的链表版)
本文选取ArrayList类部分源码进行解析
目录
底层数据结构
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
...
transient Object[] elementData; // non-private to simplify nested class access
...
}
ArrayList的底层数据结构是一个对象数组
当ArrayList对象调用add方法添加集合元素时,集合元素就被添加到这个名为elementData的Object数组中
添加方法---add
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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++;
}
add方法是两个互为重载方法
前者是普通的添加元素
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);
}
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);
}
方法体首先调用方法ensureCapacityInternal(size + 1),若elementData从未添加过元素,则获取size+1与private static final int DEFAULT_CAPACITY = 10; 比较,较大者则为初始长度,后再比较当前数组长度,若此时长度比数组长度大且不超过Integer最大值2147483647,则通过grow方法获取一个原数组长度1.5倍的新elementData数组
后者是指定索引位置添加元素,只是在前者的基础上多了索引是否在elementData数组长度范围内的检查 若超出则抛出数组越界异常IndexOutOfBoundsException
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
在数组长度范围内则调用System.arraycopy方法获得一个在指定索引处添加了新元素的新数组
检查包含方法---contains
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
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;
}
通过查看源码我们可以知道,contains方法底层依赖于equals()方法,这意味着当我们的ArrayList对象存储的是对自定义对象时,需要重写equals方法,否则默认的equals方法比较的是地址,没什么意义
与Vector、LinkedList部分代码对比
学习了ArrayList的重点方法后,我们再来对比Vector与LinkedList方法,便能发现 其实原理都差不多,以add方法为例
Vector
public synchronized boolean add(E e) { // 线程安全
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
在方法处加了synchronized关键字 保证了线程安全
LinkedList
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
Node<E>相当于双向链表的一个节点,节点保存着上一节点位置及下一节点位置,通过transient Node<E> first;指向双向链表头结点