一.AbstractCollection抽象类:(提供了Collection接口的骨干实现,以减少实现接口所需要的工作)
1.contains方法
contains方法,通过迭代器对于列表的每一个元素进行遍历,并且判断是否与给定的元素相等.另外由于传入的元素可能为null,因此在执行传入的元素的equals方法的时候,需要先判断是否为null.源代码如下:
public boolean contains(Object o) {
Iterator<E> it = iterator();
if (o==null) {
while (it.hasNext()) //迭代器的hasNext的实现通常是拿索引和容器容量作比较.因此当容器为null时,返回的是false
if (it.next()==null) //只有当迭代的元素为null时返回true,
return true;
} else {
while (it.hasNext()) //进行迭代.
if (o.equals(it.next())) //调用equals方法判断(传入的对象的equals方法)
return true;
}
return false;//集合为null或者没有找到对应的元素的时候
}
2.toArray()方法
空参的toArray方法,在方法内部定义了一个Object数组,并且对于容器内部的元素采用迭代器进行遍历,并且将每个元素放置于Object数组中.
public Object[] toArray() {
// 估计数组的大小;可能会有更多或者更少的元素
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // 比预想的元素要少
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it)/*比预想的元素多*/ : r;
}
3.toArray(T[])方法
这个方法如果给定的数组够大,则将结束索引的元素设为null,否则建立一个新的数组并且返回.
public <T> T[] toArray(T[] a) {
/* 将数组的大小设为容器的大小
参数指定的数组大于容器的大小,则在参数的数组设置值
否则new一个新的数组
getComponentType返回的是数组组件的类型
*/int size = size();
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) { //比预期的更少
if (a == r) {
r[i] = null; // 将索引i处的位置设为null
} else if (a.length < i) {
return Arrays.copyOf(r, i);//返回copy的数组（重新新建立一个数组）
} else {
System.arraycopy(r, 0, a, 0, i);
if (a.length > i) {
a[i] = null;//将索引i处的位置设为null
}
}
return a;
}
r[i] = (T)it.next();
}
//比预期的元素更多
return it.hasNext() ? finishToArray(r, it) : r;
}
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length;
while (it.hasNext()) {
int cap = r.length;
if (i == cap) {
int newCap = cap + (cap >> 1) + 1;
if (newCap - MAX_ARRAY_SIZE > 0)
newCap = hugeCapacity(cap + 1);
r = Arrays.copyOf(r, newCap);//扩充容量
}
r[i++] = (T)it.next();
}
// 如果i与r.length相等,返回r否则返回copy的数组
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
4.addAll方法
addAll方法:直接对Collection中的每个元素进行add方法的调用,只要调用成功了则返回true.
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;//只要添加成功,modified设为true
return modified;
}
二.AbstractList类
此类提供 List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。对于连续的访问数据（如链表），应优先使用 AbstractSequentialList，而不是此类.
要实现可修改的列表，编程人员必须另外重写 set(int, E) 方法（否则将抛出UnsupportedOperationException）。如果列表为可变大小，则编程人员必须另外重写 add(int, E) 和 remove(int) 方法。
例如在AbstractList中,set方法是这样实现的:
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
1.indexOf方法
和contains方法实现几乎相同,但是采用了ListIterator对容器内部的元素进行了遍历:
public int indexOf(Object o) {
ListIterator<E> it = listIterator();
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return it.previousIndex();
} else {
while (it.hasNext())
if (o.equals(it.next()))
return it.previousIndex();//此时索引已经加1.需要用privioutsIndex来获取索引
}
return -1;
}
2.clear方法
clear方法采用ListIterator来实现对于指针经过的元素进行删除:
public void clear() {
removeRange(0, size());//改变容量大小的操作
}
protected void removeRange(int fromIndex, int toIndex) {
ListIterator<E> it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();
it.remove();
}
}
3.迭代器内部实现:
在AbstractList中定义了内部类,实现了迭代器接口,实现了对于元素的遍历.Itr(普通迭代器)的实现,在迭代器内部定义了一个指针,每次返回元素后,指针将会指向下一个元素,继续返回,直到计数器达到容器的大小.同时迭代器的实现也解释了不能还没有调用next,就remove,也不能连续调用两次remove方法的原因:未调用next就remove,由于lastret值为-1,会报异常,而在第一次调用remove后,lastret值变为-1,如果再次调用remove也会发生异常!
private class Itr implements Iterator<E> {
/**
* 下一个元素的索引
*/
int cursor = 0;
/**
* 前一个元素的索引
*/
int lastRet = -1;
/**
* 记录容器被修改的次数
*/
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();//检查遍历的时候容器有没有被修改过
try {
int i = cursor;
E next = get(i);//获取元素
lastRet = i; //lastRet记录获取到的元素的索引
cursor = i + 1;//cursor+1,准备获取接下来的元素
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet < 0) //这行代码解释了,不能未调用next()就remove() 也不能连续调用两次remove()
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
ListIterator的实现,和Iterator实现基本相同,它继承了Itr类,区别在于它支持在调用next或者privious后,添加元素.这里根据源代码分析.在调用next的时候,调用add,add方法会在cursor指针(下一个要next的元素)的位置添加元素.并将cursor+1,使得next的调用无法返回添加的元素.在调用privious的时候,调用add,add方法会在已经返回的元素的位置处,添加元素,并将cursor+1,这时候,下次返回的将是cursor-1的元素,即新添加的元素.
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index; //将元素指针设为指定值
}
public boolean hasPrevious() {
return cursor != 0;
}
public E previous() {
checkForComodification(); //检查是否被修改
try {
int i = cursor - 1;
E previous = get(i);
lastRet = cursor = i;//结束该方法调用的时候,cursor位置停留在返回的元素的位置上,这点与next不同
return previous;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
/*
add方法在next后调用下一个next无法返回新添加的元素
在privious后调用,下一个privious可以返回.
实际上无论是在next还是在privious方法后调用,
add方法都使得指针向前移动了1位.
*/
try {
int i = cursor;
AbstractList.this.add(i, e);
lastRet = -1;
cursor = i + 1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
4.equals方法的实现:
equals方法采用ListIterator方法对于每一个元素都进行了遍历,在调用ListIerator方法之前,需要先判断是否指向同一对象或者是否运行时类相同.
public boolean equals(Object o) {
if (o == this) //是否指向同一个对象
return true;
if (!(o instanceof List)) //是否都是List对象
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext()); //如果有一方还有多余的元素,那么判断不成立
}
5.subList方法
该方法new了一个List并且在这里List里持有源容器对象的引用.可以通过更改这个List,更改原来的容器(这样的List又称为源容器的视图),offset索引指示了视图与容器的偏移量.
/*
该方法new了一个List并且在这里List里持有源容器对象的引用.
可以通过更改这个List,更改原来的容器
*/
public List<E> subList(int fromIndex, int toIndex) {
return (this instanceof RandomAccess ?
new RandomAccessSubList<>(this, fromIndex, toIndex) :
new SubList<>(this, fromIndex, toIndex));
}
class SubList<E> extends AbstractList<E> {
private final AbstractList<E> l;//持有原容器对象的引用
private final int offset;
private int size;
SubList(AbstractList<E> list, int fromIndex, int toIndex) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > list.size())
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
l = list;
offset = fromIndex;
size = toIndex - fromIndex;
this.modCount = l.modCount;
}
public E set(int index, E element) {
rangeCheck(index);
checkForComodification();
return l.set(index+offset, element);//可以通过更改subList来设置原容器对象
}
....}
时间： 2024-10-12 02:10:20