Java Collection 06 - AbstractSequentialList

关于 java.util.AbstractSequentialList<E> 的部分笔记。AbstractSequentialList因其借鉴顺序访问的思想而被用于插入元素比访问元素更频繁的场景中。顺序访问思想赋予了其插入元素可以做到常量时间的优势。鉴于其是一个抽象类，在实际应用时实现其抽象方法来完成实际操作。需要本文演示代码段的执行环境基于JDK版本1.7。

概述

AbstractSequentialList提供了顺序访问List集合的一种思路和实现，其最常见的实现类即为 LinkedList。和以AbstractList为代表的随机访问类相比，顺序访问会导致在访问元素时会按照从首到尾逐个遍历的方式获取目标元素，所以其访问元素需要的时间随着集合元素数量呈比例增长，但是其优点是保证了元素插入的高效率。

鉴于AbstractSequentialList已经实现了List和Collection接口的部分方法，所以如果单纯的实现一个AbstractSequentialList的话，只需要实现listIterator(int index)和size()方法即可。如果需要实现一个不可修改的List集合，那么只需要实现listIterator的hasNext()、next()、hasPrevious()和index()方法即可。

如果需要实现一个可修改的List集合，除了上述提及方法外还需要实现listIterator的set()方法。如果需要实现一个长度可变的List集合，还需要额外实现listIterator的remove()和add()方法。

继承关系

// AbstractSequentialList<E>
--java.lang.Object
  --java.util.AbstractCollection<E>
    --java.util.AbstractList<E>
      --java.util.AbstractSequentialList<E>

实现接口

类名	实现接口
AbstractSequentialList<E>	Iterable<E>, Collection<E>, List<E>

AbstractSequentialList

Constructor Summary

protected AbstractSequentialList()

1 2	protected AbstractSequentialList() { }

默认构造函数。采用protected修饰的原因是因为AbstractSequentialList不直接用于集合的初始化操作，而是在使用真正可用的list集合处理类时提供一些基础准备工作。所以这个方法不应该暴露到外界去，所以不能用public修饰。同样的原因，因为AbstractSequentialList不涉及到单例模式的设计，所以也不会是private，这样其子类也没办法继承到父类的无参构造方法。所以综上考虑，protected是最理想的选择。

部分方法

public E get(int index)

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

返回index位置下标的元素。通过初始化一个遍历位置自index起的listIterator，然后借助这个listIterator的next()方法来完成元素的获取和返回。

public E set(int index, E element)

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);
    }
}

用element替换List集合中下标为index的元素，并返回被替换的元素。

public void add(int index, E element)

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

将元素element加入到List集合Index位置上。

public E remove(int 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);
    }
}

移除List集合中index位置上的元素，并返回被移除的元素。

public boolean addAll(int index, Collection<? extends E> c)

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);
    }
}

将集合c中的元素加入到List集合中自index位置起的空间里。被加入到List集合的元素的前后顺序和其在c中的顺序一致。

public Iterator\ iterator()

1
2
3

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

返回一个可以遍历当前List集合的迭代器。实际调用的是AbstractList中的listIterator()方法，其开始遍历位置默认为0。

public abstract ListIterator\ listIterator(int index)

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

返回一个可以遍历当前List集合的迭代器，其开始遍历位置由index指定。该方法被声明为抽象方法，需要在子类中实现该方法。

Mr.Muzi