AbstractList给List提供了一个骨架实现，它的声明是这样的：
public abstract class AbstractList extends AbstractCollection implements List
继承AbstractCollection，实现List接口。
有关AbstractCollection：http://blog.csdn.net/treeroot/archive/2004/09/11/101622.aspx
有关List： http://blog.csdn.net/treeroot/archive/2004/09/14/104638.aspx
下面来看一下该类中的方法
public boolean add(Object o) {
add(size(), o);
return true;
}
直接调用方法add(int index,Object o)在末尾插入一个数据
abstract public Object get(int index);
该方法未实现
public Object set(int index, Object element) {
throw new UnsupportedOperationException();
}
该方法不受支持
public void add(int index, Object element) {
throw new UnsupportedOperationException();
}
该方法不受支持，这个方法直接影响上面的public boolean add(Object o)方法。
public Object remove(int index) {
throw new UnsupportedOperationException();
}
该方法不受支持
public int indexOf(Object o) {
ListIterator e = listIterator();
if (o==null) {
while (e.hasNext())
if (e.next()==null)
return e.previousIndex();
} else {
while (e.hasNext())
if (o.equals(e.next()))
return e.previousIndex();
}
return -1;
}
该方法获得指定元素在列表中的索引，正向搜索，找到的是一个最小值。
找不到的话就返回-1，找不到的情况就要遍历整个列表。
public int lastIndexOf(Object o) {
ListIterator e = listIterator(size());
if (o==null) {
while (e.hasPrevious())
if (e.previous()==null)
return e.nextIndex();
} else {
while (e.hasPrevious())
if (o.equals(e.previous()))
return e.nextIndex();
}
return -1;
}
这个方法几乎和上面的是一样的，不过是从后面向前面找而已，找到的是一个索引的最大值。
public void clear() {
removeRange(0, size());
}
清楚两个索引之间的所有元素，包括开始，不包括结束，参见removeRange方法。
public boolean addAll(int index, Collection c) {
boolean modified = false;
Iterator e = c.iterator();
while (e.hasNext()) {
add(index++, e.next());
modified = true;
}
return modified;
}
这个方法通过循环调用add方法来实现，因为每次调用add方法都要完成元素的后移，所以一种需要移动
c.size()次，效率比较低下。子类中一般都会覆盖这个方法。
public Iterator iterator() {
return new Itr();
}
这里有一个内部类Itr,参见下面的定义。
public ListIterator listIterator() {
return listIterator(0);
}
返回默认的列表迭代器，起始位置在最前面。
public ListIterator listIterator(final int index) {
if (index<0 || index>size())
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
｝
先检查越界情况，同样有一个内部类ListItr，参见下面的定义。
以下是Itr的定义：
有关Iterator接口：http://blog.csdn.net/treeroot/archive/2004/09/11/101589.aspx
私有的内部类
private class Itr implements Iterator {
int cursor = 0;
记录游标位置
int lastRet = -1;
最后一次调用next()或者previous()的索引，其实Iterator都没有定义previous()。
int expectedModCount = modCount;
记录修改次数，modCount在AbstractList中定义为结构话改变List的次数。
这里是为了在Iterator和ListIterotor访问List时出现并发访问，我们后面再讨论这个问题。
public boolean hasNext() {
return cursor != size();
}
如果当前游标不等于集合的大小(那么肯定０到size()-1中的一个值)说明还有下一个值。
size()是AbstractList中的方法。
public Object next() {
try {
Object next = get(cursor);
checkForComodification();
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
这里比较讨厌的是调用了AbstractList中的方法get(int index)，这里捕捉了一个系统异常(可以不
捕捉的异常)IndexOutOfBoundsException。无论如何都先抛出并发访问异常ConcurrentModificationException
(如果有的话）。正常情况下当前游标和最后一次访问索引都加1。
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
如果最后一次访问的索引是-1(刚获得Iterator时就是这样的),抛出IllegalStateException异常。
否则就删除该元素，如果该元素在当前游标之前，游标值要前移。因为是Iterator改变了List的结构，
这里要修正expertedModCount值。这里如果删除的时候的时候越界，一定是其他地方在修改这个List,
所以抛出并发访问异常。注意：这里把lastRet设置为了-1，此时不能调用remove以及ListIterator中
的add,set方法了。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
如果两个地方记录的修改次数不一样，说明还有其他地方在修改这个List。
｝
以下是ListItr的定义：
有关ListIterator接口:http://blog.csdn.net/treeroot/archive/2004/09/14/104608.aspx
内部私有类
private class ListItr extends Itr implements ListIterator {
ListItr(int index) {
cursor = index;
}
构造函数，初始化当前游标位置。
public boolean hasPrevious() {
return cursor != 0;
}
当前游标不为０表示前面有元素。
public Object previous() {
try {
int i = cursor - 1;
Object previous = get(i);
checkForComodification();
lastRet = cursor = i;
return previous;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
返回当前游标的前一个元素，游标值和最后一次访问索引都有改变，有关并发控制参考Itr
public int nextIndex() {
return cursor;
}
下一个元素的索引和当前游标相等。
public int previousIndex() {
return cursor-1;
}
不用多说
public void set(Object o) {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, o);
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
调用外围类的set方法，并发控制参考Itr中remove方法的说明。
public void add(Object o) {
checkForComodification();
try {
AbstractList.this.add(cursor++, o);
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
参考Itr中remove方法的说明。
}
回到AbstractList的方法
public List subList(int fromIndex, int toIndex) {
return (this instanceof RandomAccess ?
new RandomAccessSubList(this, fromIndex, toIndex) :
new SubList(this, fromIndex, toIndex));
}
如果该List实现了RandomAccess接口，返回一个新的RandomAccessSubList实例，
否则返回一个SubList实例，这两个类在后面定义。
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while(e1.hasNext() && e2.hasNext()) {
Object o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
这个方法比较简洁，通过遍历两个列表来比较,只有两个列表的元素以及顺序完全一样才相等。
public int hashCode() {
int hashCode = 1;
Iterator i = iterator();
while (i.hasNext()) {
Object obj = i.next();
hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}
return hashCode;
}
这种算法完全可以保证：两个List相等时他们的hashCode也相等。
protected void removeRange(int fromIndex, int toIndex) {
ListIterator it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();
it.remove();
}
}
这里通过迭代器来删除指定的元素，而迭代器调用的是remove方法，所以这个方法的效率不高。
protected transient int modCount = 0;
这个域表示该List被修改的次数，目的是为了控制并发访问。
AbstractList的内容已经结束，但是我们还用到了两个类：RandomAccessList和SubList。
看看SubList的定义：
class SubList extends AbstractList {
private AbstractList l;
private int offset;
private int size;
private int expectedModCount;
SubList(AbstractList 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;
expectedModCount = l.modCount;
}
public Object set(int index, Object element) {
rangeCheck(index);
checkForComodification();
return l.set(index+offset, element);
}
public Object get(int index) {
rangeCheck(index);
checkForComodification();
return l.get(index+offset);
}
public int size() {
checkForComodification();
return size;
}
public void add(int index, Object element) {
if (index<0 || index>size)
throw new IndexOutOfBoundsException();
checkForComodification();
l.add(index+offset, element);
expectedModCount = l.modCount;
size++;
modCount++;
}
public Object remove(int index) {
rangeCheck(index);
checkForComodification();
Object result = l.remove(index+offset);
expectedModCount = l.modCount;
size--;
modCount++;
return result;
}
protected void removeRange(int fromIndex, int toIndex) {
checkForComodification();
l.removeRange(fromIndex+offset, toIndex+offset);
expectedModCount = l.modCount;
size -= (toIndex-fromIndex);
modCount++;
}
public boolean addAll(Collection c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection c)｛
if (index<0 || index>size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
int cSize = c.size();
if (cSize==0)
return false;
checkForComodification();
l.addAll(offset+index, c);
expectedModCount = l.modCount;
size += cSize;
modCount++;
return true;
}
public Iterator iterator() {
return listIterator();
}
public ListIterator listIterator(final int index) {
checkForComodification();
if (index<0 || index>size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
return new ListIterator() {
private ListIterator i = l.listIterator(index+offset);
public boolean hasNext() {
return nextIndex() < size;
}
public Object next() {
if (hasNext())
return i.next();
else
throw new NoSuchElementException();
}
public boolean hasPrevious() {
return previousIndex() >= 0;
}
public Object previous() {
if (hasPrevious())
return i.previous();
else
throw new NoSuchElementException();
}
public int nextIndex() {
return i.nextIndex() - offset;
}
public int previousIndex() {
return i.previousIndex() - offset;
}
public void remove() {
i.remove();
expectedModCount = l.modCount;
size--;
modCount++;
}
public void set(Object o) {
i.set(o);
}
public void add(Object o) {
i.add(o);
expectedModCount = l.modCount;
size++;
modCount++;
}
};
}
public List subList(int fromIndex, int toIndex) {
return new SubList(this, fromIndex, toIndex);
}
private void rangeCheck(int index) {
if (index<0 || index>=size)
throw new IndexOutOfBoundsException("Index: "+index+
",Size: "+size);
}
private void checkForComodification() {
if (l.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
｝
这个类继承AbstractList，基本上很好理解，不过有几点需要主要：
1.注意l.modCount,modCount,expectedModCount的区别，modCount是SubList继承过来的域
expectedModCount是SubList为防止并发访问新加的域，l.modCount当然好理解。
2.public ListIterator listIterator(final int index)方法中用了一个匿名类。
3.注意SubList的构造函数只有一个，需要带三个参数，而且SubList只是一个视图，修改SubList
也就等于修改了参数中的list。
最后是RandomAccessSubList
class RandomAccessSubList extends SubList implements RandomAccess {
RandomAccessSubList(AbstractList list, int fromIndex, int toIndex) {
super(list, fromIndex, toIndex);
}
public List subList(int fromIndex, int toIndex) {
return new RandomAccessSubList(this, fromIndex, toIndex);
}
}
这个类没有什么实在的东西，不过是类型和SubList不一样而已(因为多了一个RandomAccess接口).
这里只是分析了这个类的实现，并没有评价这个类设计的好坏，不过我是比较讨厌嵌套类(特别是嵌套
类还能调用外围类的方法),另外SubList返回的是一个视图，而不是一个完全独立的List，这样到底好不好呢？
