解析java.util集合类源码(AbstractSequentialList)

抽象类AbstractSequentialList

AbstractSequentialList继承AbstractList，对其中的方法进行再抽象，不同于动态数组列表ArrayList

先看一下整体结构

AbstractSequentialList在功能上，最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。

对于随机访问数据（如数组），应该优先使用 AbstractList，而不是先使用此类

说白了就是你的列表需要快速的添加删除数据等，用此抽象类，若是需要快速随机的访问数据等用AbstractList抽象类

 public E get(int index) {
        try {
            return listIterator(index).next();
        } catch (NoSuchElementException exc) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }
    }

用迭代器返回元素

public E set(int index, E element) {
	try {
	    ListIterator<E> e = listIterator(index);
	    E oldVal = e.next();
	    e.set(element);
	    return oldVal;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

先用迭代器找到该元素，在用迭代器对其位置上的元素修改

public void add(int index, E element) {
	try {
	    listIterator(index).add(element);
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

public E remove(int index) {
	try {
	    ListIterator<E> e = listIterator(index);
	    E outCast = e.next();
	    e.remove();
	    return outCast;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

都是用迭代器

public boolean addAll(int index, Collection<? extends E> c) {
	try {
	    boolean modified = false;
	    ListIterator<E> e1 = listIterator(index);
	    Iterator<? extends E> e2 = c.iterator();
	    while (e2.hasNext()) {
		e1.add(e2.next());
		modified = true;
	    }
	    return modified;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

迭代外部的集合，将外部集合的元素放到本列表中

public Iterator<E> iterator() {
        return listIterator();
    }

public abstract ListIterator<E> listIterator(int index);

重写了AbstractList中的iterator和listIterator方法，AbstractList中的这个方法便用于ArrayList这种底层顺序表实现的列表

但用在LinkedList这种底层链表机制的列表就不太适用，这里将listIterator重写为抽象方法，放在具体的实现类中按照需求去实现