ArrayList
- 1、继承与实现
- 2、变量与常量
- 3、初始化方法
- 4、其他方法
- 4.1、void trimToSize()
- 4.2、void grow(int minCapacity)
- 4.3、int hugeCapacity(int minCapacity)
- 4.4、int size()
- 4.5、boolean isEmpty()
- 4.6、boolean contains(Object o)
- 4.7、int indexOf(Object o)
- 4.8、int lastIndexOf(Object o)
- 4.9、Object clone()
- 4.10、E get(int index)
- 4.11、E set(int index, E element)
- 4.12、boolean add(E e)
- 4.13、E remove(int index)
- 4.14、void clear()
- 4.15、boolean addAll(Collection<? extends E> c)
- 4.16、boolean removeAll(Collection<?> c)
- 4.17、boolean batchRemove(Collection<?> c, boolean complement)
- 5、内部类
( 如有错误,敬请指正)
主要参考JDK源码,有一些看不懂的会百度
ArrayList里面的数据是由数组存储的,所以访问起来非常方便
同时里面也调用了很多Arrays的方法
1、继承与实现
继承 extends AbstractList<E>
实现 implements List<E>, RandomAccess, Cloneable, java.io.Serializable
2、变量与常量
- 常量
private static final int DEFAULT_CAPACITY = 10;
默认初始容量为10;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
最大的数组数量是整形的最大值-8
- 变量
private int size;
包含的元素个数(这是元素个数要与容量区分开来);
transient Object[] elementData;
数据
Any empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
will be expanded to DEFAULT_CAPACITY when the first element is added.
大概意思是:
当空ArrayList 添加第一个元素时,空ArrayList 容量将扩展为默认容量DEFAULT_CAPACITY (10)
3、初始化方法
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);
}
}
初始化容量为initialCapacity的ArrayList(会有对initialCapacity的判断)
如果initialCapacity大于0,ArraysList的数据就等于长度为initialCapacity的Object数组
如果initialCapacity等于0,ArraysList的数据就等于 {}
如果initialCapacity小于0,抛出异常
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;
}
}
Collection<? extends E> c
是指继承了E类是吸实现了Collection接口的java类型。
这个没太看懂。
4、其他方法
4.1、void trimToSize()
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
如果size 小于elementData的长度(也就是元素数量)
elementData只留下前size个元素
多出来的元素丢弃。
4.2、void grow(int minCapacity)
容量不足时java会自动调动这个方法
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);
}
可以看到在扩展容量的时候,会在原来elementData元素数量的基础上增加elementData元素数量的一半。newCapacity = oldCapacity + (oldCapacity >> 1);
扩容的思路是给elementData赋新值
还用到了下面的方法
4.3、int hugeCapacity(int minCapacity)
静态方法
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
4.4、int size()
返回变量size
4.5、boolean isEmpty()
如果size等于0,返回true
4.6、boolean contains(Object o)
如果包含元素o就返回true(用到如下方法)
4.7、int indexOf(Object o)
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;
}
求元素o在ArrayList中的位置
方法就是从头遍历elementData数组,
遇到等于o的,不再遍历,返回此时数组下标
遍历完都没有遇到就返回-1
4.8、int lastIndexOf(Object o)
返回最后一个等于o的元素下标,思路是从后往前遍历,类似上一个。
4.9、Object clone()
这里new 另一个新对象,与原来的ArrayList的元素和size都一样,并返回。(如果size小于元素数量多出来的要丢弃)
4.10、E get(int index)
获取下标为index的元素(E get(int index)是一样的用法),这个会判断index是否越界,但是elementData(int index)不会判断越界。
4.11、E set(int index, E element)
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
把下标为index的元素替换为element,并返回替换掉的元素。
4.12、boolean add(E e)
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
首先要确保数组的容量放得下这个元素(也就是至少有一个空位),如果放不下会调用grow扩充容量。
这里有几点要注意
假如我们声明了一个空ArrayList那么第一次add元素的时候会直接扩容到10,当已经有十个元素再添加时才会进行下一次扩容。
4.13、E remove(int 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; // clear to let GC do its work
return oldValue;
}
主要用到了System.arraycopy方法,可是这个方法夫人方法体我没有找到
还有一个方法fastRemove(int index)快速移除
这个方法快就快在不用获取并返回要删除的元素
4.14、void clear()
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
这个方法需要注意的是他是遍历数组把每一个对象重新赋值为null
size赋值为0
但是elementData.lenght应该还是原来的length
4.15、boolean addAll(Collection<? extends E> c)
把这些元素全部插入,而且是插入到原有元素的前面
类似方法boolean addAll(int index, Collection<? extends E> c)是从下标为index开始插入
很多方法都用到了System.arraycopy()看来这个方法是把两段拼成一个数组。
4.16、boolean removeAll(Collection<?> c)
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
Objects.requireNonNull©;排除c为null的情况,如果为null抛出异常
此方法调用了下面方法
4.17、boolean batchRemove(Collection<?> c, boolean complement)
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
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.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
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;
}
顾名思义 批量移除 ,complement为true时是删除所有在c中存在的元素。
complement为false时是删除所有在c中没有出现的元素
注意:是c中有或没有不是elementData中有或没有
c.contains(elementData[r]) == complement
5、内部类
这个里面好多内部类,有迭代器,还有分割数组的。
内容太多了,以后有机会吧!