文章目录
-
- ArrayList继承图
- ArrayList相关属性
- 构造器
- 相关方法
-
- trimToSize
- ensureCapacity
- ensureCapacityInternal
- ensureExplicitCapacity
- grow
- hugeCapacity
- size
- isEmpty
- contains
- indexOf
- lastIndexOf
- clone
- toArray
- toArray(T[] a)
- elementData
- get
- set
- add
- add(int index, E element)
- remove
- remove(Object o)
- fastRemove
- clear
- addAll
- addAll(int index, Collection<? extends E> c)
- removeRange
- removeAll
- retainAll
- batchRemove
- writeObject
- readObject
- listIterator(int index)
- listIterator
- iterator
- subList
- 内部类
ArrayList继承图
直接继承了AbstractList抽象类,实现了RandomAccess,Serializable,Cloneable接口
AbstractList:对List接口的简单部分实现。
RandomAccess:标识类是否可以随机访问。
Serializable:标识类是否可以序列化与反序列化,实现了Serializable接口的类可以被ObjectOutputStream转换为字节流,同时也可以通过ObjectInputStream再将其解析为对象。
Cloneable:标识类是否可以使用Object的clone()。
ArrayList相关属性
/**
/**
* 默认初始容量大小
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 空数组数据
*/
private static final Object[] EMPTY_ELEMENTDATA = {
};
/**
* 默认容量为空的数组,以跟EMPTY_ELEMENTDATA区分开,当不对容量进行赋值的时候使用
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};
/**
* 元素数据
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* list大小
*/
private int size;
以及AbstractList继承的属性
// 用来标识List的结构改变次数
protected transient int modCount = 0;
构造器
ArrayList()
当new ArrayList()时执行该构造器
public ArrayList() {
// 赋值为默认空数据
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ArrayList(int initialCapacity)
当执行new ArrayList(10)时执行该构造器
public ArrayList(int initialCapacity) {
// 如果容量大小大于0,new 一个Object的数组
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 容量等于0,赋值为EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
ArrayList(Collection<? extends E> c)
传递一个容器接口的实现类给构造器,根据其实现构建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;
}
}
相关方法
trimToSize
修剪list大小,如果size小于elementData数组的长度,那么修改elementData的长度到size长度。
public void trimToSize() {
// 修改了数组结构
modCount++;
if (size < elementData.length) {
// 如果size=0则为EMPTY_ELEMENTDATA,否则赋值为size大小的数组
elementData = (size == 0)
? EMPTY_ELEMENTDATA
// Array.copyOf(从elementData中复制size长度的数组)
: Arrays.copyOf(elementData, size);
}
}
ensureCapacity
预设ArrayList的大小,当ArrayList的容量较大时,可以加快速率,外部调用。如果要扩容调用ensureExplicitCapacity
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);
}
}
ensureCapacityInternal
确保内部容量,内部方法调用,如果要扩容调用ensureExplicitCapacity
private void ensureCapacityInternal(int minCapacity) {
// 如果最开始为默认空数组,则默认大小为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
ensureExplicitCapacity
确保显式容量,如果需要扩容则调用grow方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
grow
扩容方法,默认扩容1.5倍,如果1.5倍不够或者溢出(为负数)则赋值为minCapacity,如果newCapacity 大于Integer.MAX_VALUE - 8
则调用hugeCapacity方法获得大容量的值。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 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);
}
hugeCapacity
返回容器大容量时的容量值,一般返回Integer.MAX_VALUE
。
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
size
返回列表大小。
public int size() {
return size;
}
isEmpty
判断列表是否为空,直接判断size是否等于0
public boolean isEmpty() {
return size == 0;
}
contains
判断列表是否包含某个元素,通过indexOf方法判断,如果其值大于等于0表示存在。
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
indexOf
返回指定元素所在的索引值,如果元素不存在则返回-1
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;
}
lastIndexOf
返回指定元素所在的最后一个索引值,如果元素不存在则返回-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;
}
clone
克隆,只有实现了Cloneable接口的才能使用,先调用Object的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);
}
}
toArray
将列表转化为数组,直接调用了Arrays.copyOf方法
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
toArray(T[] a)
将列表转化为指定类型的数组
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;
}
elementData
获取指定索引处的元素
E elementData(int index) {
return (E) elementData[index];
}
get
先检查index是否在范围中,然后返回值
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
set
返回旧值,并设置新值
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
add
添加一个元素到列表中,modCount会增加。先检查容量是否足够。
public boolean add(E e) {
// 检查内部容量
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
add(int index, E element)
在指定索引处添加元素
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
// 从elementData的index位置开始复制size-index个元素到elementData的index+1位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
remove
移除指定索引处的元素,modCount会增加。
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;
}
remove(Object o)
移除指定元素,modCount增加。如果元素为null,遍历一次,判断是否有值为null,然后删除;如果元素不为null,使用equals判断是否有元素相同,然后调用fastRemove方法删除。
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;
}
fastRemove
删除对象实现方法,modCount增加
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; // clear to let GC do its work
}
clear
清理所有elementData数据方法,modCount增加。
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
addAll
添加Collection接口实现类中的所有元素,如果容量不够会modCount增加扩容。先判断确保容量大小是否足够,然后调用System.arraycopy复制。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
addAll(int index, Collection<? extends E> c)
在指定索引处,插入Collection接口实现类中的所有数据。如果容量不够会modCount增加扩容。
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(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;
}
removeRange
删除指定fromIndex到toIndex中的数据,modCount增加。
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
removeAll
从本ArrayList中移除Collection接口实现类中所有的对象。调用batchRemove方法
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
retainAll
保留本ArrayList在Collection接口实现类中存在的对象。调用batchRemove方法
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
batchRemove
批量移动,modCount += size - w。w为符合条件的元素数量,可能是需要移除的,可能是需要保留的。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
// r表示读取的数据数量,w表示写的数据数量
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
// 没有读取完,直接把后面的元素放置w后面
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
// 如果w跟size不同
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
writeObject
写对象到ObjectOutputStream中
readObject
从ObjectInputStream中读取对象
listIterator(int index)
返回从指定index开始的一个列表迭代器。
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
listIterator
返回从0开始的列表迭代器。
public ListIterator<E> listIterator() {
return new ListItr(0);
}
iterator
返回一个迭代器。
public Iterator<E> iterator() {
return new Itr();
}
subList
返回一个子列表
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
内部类
ArrayList.java中包含的内部类。
Itr
迭代器实现类
private class Itr implements Iterator<E> {
// 下一个返回元素的索引值
int cursor; // index of next element to return
// 返回的最后一个索引值
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
// 先获取cursor数据,再cursor加1
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
// 先删除lastRet,再cursor=lastRet,因为lastRet删除了,所以lastRet的值就是后续的值
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
// 对于剩余的进行遍历
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
// 检查是否并发
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
ListItr
列表迭代器实现类
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@SuppressWarnings("unchecked")
// 返回列表的前一个元素,并将光标后移
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
// 在cursor位置添加元素,然后cursor+1
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
SubList
子列表实现类
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
// 相对于上一级的偏移量
private final int parentOffset;
// 相对于ArrayList的偏移量
private final int offset;
int size;
// ……省略
}
ArrayListSpliterator
ArrayList分离器
static final class ArrayListSpliterator<E> implements Spliterator<E> {
private final ArrayList<E> list;
private int index; // current index, modified on advance/split
// 直到使用前都为-1,否则为最后一个索引
private int fence; // -1 until used; then one past last index
// fence 设置时初始化
private int expectedModCount; // initialized when fence set
/** Create new spliterator covering the given range */
ArrayListSpliterator(ArrayList<E> list, int origin, int fence,
int expectedModCount) {
this.list = list; // OK if null unless traversed
this.index = origin;
// fence 一般等于list.size()
this.fence = fence;
this.expectedModCount = expectedModCount;
}
private int getFence() {
// initialize fence to size on first use
int hi; // (a specialized variant appears in method forEach)
ArrayList<E> lst;
if ((hi = fence) < 0) {
if ((lst = list) == null)
hi = fence = 0;
else {
expectedModCount = lst.modCount;
hi = fence = lst.size;
}
}
return hi;
}
// 尝试分一半
public ArrayListSpliterator<E> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid) ? null : // divide range in half unless too small
new ArrayListSpliterator<E>(list, lo, index = mid,
expectedModCount);
}
// 尝试使index的元素执行action.accept,然后index+1
public boolean tryAdvance(Consumer<? super E> action) {
if (action == null)
throw new NullPointerException();
int hi = getFence(), i = index;
if (i < hi) {
index = i + 1;
@SuppressWarnings("unchecked") E e = (E)list.elementData[i];
action.accept(e);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
return false;
}
// 对剩余的元素执行action.accept
public void forEachRemaining(Consumer<? super E> action) {
int i, hi, mc; // hoist accesses and checks from loop
ArrayList<E> lst; Object[] a;
if (action == null)
throw new NullPointerException();
if ((lst = list) != null && (a = lst.elementData) != null) {
if ((hi = fence) < 0) {
mc = lst.modCount;
hi = lst.size;
}
else
mc = expectedModCount;
if ((i = index) >= 0 && (index = hi) <= a.length) {
for (; i < hi; ++i) {
@SuppressWarnings("unchecked") E e = (E) a[i];
action.accept(e);
}
if (lst.modCount == mc)
return;
}
}
throw new ConcurrentModificationException();
}
// 预计大小
public long estimateSize() {
return (long) (getFence() - index);
}
// 分离器的特征
public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}