我们经常使用的集合,但需要去了解一下其中的源码
集合是用来存储信息,那么这里进行如下分析
1.使用什么方式存储
2.如何完成扩容的,扩容的机制是什么?
3.核心方法
4.其他方法
那么我们来看源码,首先将源码通读一遍后,可以发现,arrayList中将数据存放在一个数组中
transient Object[] elementData;
那么以后对其的增加和删除元素都是对数组的操作。
接下来它是如何完成扩容的,在平常的使用中,都不会去关注集合的容量,以为它是无限大的,然后并不是。首先对数组有一个认识后,那么对集合的初始化时,就对数组进行了初始化,要么为空,要么给定一个长度
//这个就是空的数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
private static final Object[] 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(c)该构造函数直接放一个集合放入到ArrayList中,这样集合的初始容量就为c的长度。
它的扩容机制是什么呢?
那么我们在使用add,remove的时候,是如何扩容的,
跳入到add方法中
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ensureCapacityInternal(size + 1);就是在扩容,将数组长度增加1,如果当数组为空,同时又调用了addAll(c)方法,那么数组将增加c的长度。(参看源码)
当移除时数组的长度-1,同时为了将对象的引用清空,调用了elementData[–size] = null;方法。
那么arrayList的扩容机制就是需要的时候增加或者减少数组的大小。
接下来看其中的核心的源码
经常使用到的就是get,add,remove,遍历Iterator
回忆一下我们是如何从数组中去的数据的,data[i],这样就从数组中就去得了数据,如何进行遍历了,for循环,如何删除一条数据的,data[i] = null,不过这里讲数组中的数据删除后,为了减少存储空间的碎片,调用了System.arraycopy(elementData, index+1, elementData, index, numMoved);这是将前部分和后部分进行拼接。如何添加的呢,先扩容,然后调用elementData[size++] = e;方法增加元素e。
现在有一点明白ArrayList,不过是对数组的操作进行了封装。
这里贴上其中的核心方法
//获取元素
public E get(int index) {
rangeCheck(index);//检测index是否超过了数组的长度
return elementData(index);//调用elementData(index)方法
}
E elementData(int index) {
return (E) elementData[index];//从数组中取出元素
}
//添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); //进行扩容
elementData[size++] = e;//数组尾端添加元素e
return true;
}
//在index位置上添加元素
public void add(int index, E element) {
rangeCheckForAdd(index);//检测index是否超过了数组的长度
ensureCapacityInternal(size + 1); // 扩容
System.arraycopy(elementData, index, elementData, index + 1,size - index);//思路:将元素重新移动到一个数组中,数组index空出来
elementData[index] = element;//数组index赋值
size++;//数组长度增加
}
//删除元素
public E remove(int index) {
rangeCheck(index);//检测index是否超过了数组的长度
modCount++;
E oldValue = elementData(index);//获取index位置上的元素
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);//将index前端和index的后端拼接起来,数组最后端清空,数组长度-1
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
//移除元素o,arrayList集合元素存储的值允许为null,遍历查询等于元素o的值,移除,返回true
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;
}
接下来出了使用for循环遍历arrayList,还可以使用迭代器。首先来看看我们如何使用遍历。
Iterator iter = l.iterator();
while(iter.hasNext()){
String str = (String) iter.next();
System.out.println(str);
这里使用while进行遍历,判断条件hashNext()是否为真,next()方法获取值。接下啦看看其中的源码:
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")
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];
}
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();
}
}
其中使用变量cursor,每次调用next()方法,cursor++,这个使用能够理解,上面while遍历和for循环一样,cursor相当于游标,cursor指向第一个值,每次调用next()方法,获取当前值,cursor移动到下一个元素。直到cursor==Size时while循环终止。下面还有一个方法
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();
}
}
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();
}
}
}
它继承了Itr实现了Iterator,可以进行双向迭代,这里从后向前遍历时,cursor-1。
那么迭代就是控制一个游标cursor,调用next(),previous()方法时,cursor++,cursor–。
ArrayList分析其中的源码后,应该有一下收获:
1.ArrayList集合其中使用数组存储。其中就是对数组的操作。
2.扩容机制,每次添加或删除操作后,容量就增加或减少1,而使用addAll(c)时,增加c.size()的长度。
3.迭代器,迭代器使用cursor游标,每次调用next方法,cursor移动到下一个元素。