Java中的AbstractSequentialList及其示例

AbstractSequentialList 类是Java集合框架的一部分，实现了 Collection接口 和 AbstractCollection类 。它用于实现一个不可修改的列表，只需要扩展AbstractList类并实现get()和size()方法。

此类提供了List接口的框架实现，以最小化实现使用“顺序访问”数据存储（如链表）支持的接口所需的工作量。对于随机访问数据（如数组），应优先使用AbstractList而不是此类。

类层次结构：

声明：

public abstract class AbstractSequentialList<E>
    extends AbstractList<E>

其中 E 是此List维护的元素类型。

它实现了 Iterable <E> ， Collection <E> ，List<E>接口。LinkedList是AbstractSequentialList唯一的直接子类。

构造函数： protected AbstractSequentialList() – 默认构造函数，但是由于受保护，它不允许创建AbstractSequentialList对象。

AbstractSequentialList<E> asl = new LinkedList<E>();

示例1： AbstractSequentialList是一个抽象类，因此应分配其子类的实例，例如LinkedList。

//Java代码示例AbstractSequentialList
import java.util.*;
 
public class GfG {
 
   public static void main(String[] args)
   {
       //创建AbstractSequentialList的实例
       AbstractSequentialList<Integer> absl
           = new LinkedList<>();
 
       //添加元素到absl中
       absl.add(5);
       absl.add(6);
       absl.add(7);
 
       //打印列表
       System.out.println(absl);
   } 
}

输出

[5, 6, 7]

输出结果：

[5, 6, 7]

示例2：

//Java代码示例AbstractSequentialList的方法
 
import java.util.*;
import java.util.AbstractSequentialList;
 
public class AbstractSequentialListDemo {
    public static void main(String args[])
    {
 
         //创建空AbstractSequentialList
        AbstractSequentialList<String>
            absqlist = new LinkedList<String>();
 
        //使用add()方法向列表中添加元素
        absqlist.add("Geeks");
        absqlist.add("for");
        absqlist.add("Geeks");
        absqlist.add("10");
        absqlist.add("20");
 
        //输出列表
        System.out.println("AbstractSequentialList: "
                           + absqlist);
 
        //删除头元素
        absqlist.remove(3);
 
        //输出最终列表
        System.out.println("Final List: "
                           + absqlist);
 
        //使用get()方法从列表中获取特定元素
        System.out.println("The element is: "
                           + absqlist.get(2));
    } 
}

输出结果：

AbstractSequentialList: [Geeks, for, Geeks, 10, 20]
Final List: [Geeks, for, Geeks, 20]
The element is: Geeks

AbstractSequentialList的方法

方法	描述
add(int index, E element)	将指定的元素插入到此列表中的指定位置（可选操作）。
addAll(int index, Collection c) \| 将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。 get(int index) \| 返回列表中指定位置的元素。 iterator() \| 返回此列表中元素的迭代器（按适当顺序）。 listIterator(int index) \| 返回此列表中元素的列表迭代器（按适当顺序）。 remove(int index) \| 删除此列表中指定位置的元素（可选操作）。 set(int index, E element) \| 用指定的元素（可选操作）替换此列表中指定位置的元素。 ### 从java.util.AbstractList类中继承的方法方法 \| 描述 —\|— add(E e) \| 将指定的元素追加到列表的末尾（可选操作）。 clear() \| 从列表中删除所有元素（可选操作）。 equals(Object o) \| 比较指定对象与此列表是否相等。 hashCode() \| 返回此列表的哈希代码值。 indexOf(Object o) \| 返回列表中指定元素的第一个出现的索引，如果此列表不包含元素，则返回-1。 lastIndexOf(Object o) \| 返回列表中指定元素的最后一个出现的索引，如果此列表不包含元素，则返回-1。 listIterator() \| 返回此列表中元素的列表迭代器（按适当顺序）。 removeRange(int fromIndex, int toIndex) \| 删除此列表中索引位于fromIndex（含）和toIndex（不含）之间的所有元素。 subList(int fromIndex, int toIndex) \| 返回此列表在指定fromIndex（包括）和toIndex（不包括）之间的部分的视图。 ### 从java.util.AbstractCollection类中继承的方法方法 \| 描述 —\|— addAll(Collection c) \| 将指定集合中的所有元素添加到此集合中（可选操作）。 contains(Object o) \| 如果此集合包含指定的元素，返回 true。 containsAll(Collection c)	如果此集合包含指定集合中的所有元素，则返回 true。
isEmpty()	如果此集合不包含任何元素，则返回 true。
remove(Object o)	从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
removeAll(Collection c) \| 删除此集合中也包含在指定集合中的所有元素（可选操作）。 retainAll(Collection c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
toArray()	返回包含此集合中所有元素的数组。
toArray(T[] a)	返回包含此集合中所有元素的数组；返回数组的运行时类型是指定数组的类型。
toString()	返回此集合的字符串表示形式。

从接口 java.util.Collection 继承的方法

方法	描述
parallelStream()	返回此集合作为其源的可能并行的流。
removeIf(Predicate filter) \| 移除此集合中满足给定谓词的所有元素。 stream() \| 返回此集合作为其源的顺序流。 toArray(IntFunction generator) \| 使用提供的生成器函数分配返回的数组，返回包含此集合中所有元素的数组。 ### 从接口 java.lang.Iterable 继承的方法方法 \| 描述 —\|— forEach(Consumer action) \| 对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作抛出异常为止。 ### 从接口 java.util.List 继承的方法方法 \| 描述 —\|— addAll(Collection c) \| 将指定集合中的所有元素按指定集合的iterator返回的顺序（可选操作），追加到此列表的末尾。 contains(Object o) \| 如果此列表包含指定的元素，则返回 true。 containsAll(Collection c)	如果此列表包含指定 collection 中的所有元素，则返回 true。
isEmpty()	如果此列表不包含任何元素，则返回 true。
remove(Object o)	如果存在，则从此列表中删除第一个出现的指定元素（可选操作）。
removeAll(Collection c) \| 移除此列表中包含在指定 collection 中的所有元素（可选操作）。 replaceAll(UnaryOperator operator) \| 用将该操作符应用于该元素的结果替换此列表中的每个元素。 retainAll(Collection c)	仅保留此列表中与指定 collection 中包含的元素相同的元素（可选操作）。
size()	返回此列表中的元素数。
sort(Comparator<? super E> c)	根据指定比较器的顺序对此列表进行排序。
spliterator()	在此列表中的元素上创建Spliterator。
toArray()	以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）。
toArray(T[] a)	以适当的顺序在指定的数组中返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）；返回的数组的运行时类型是指定数组的类型。

Java中的AbstractSequentialList类是AbstractList的一个子类，为允许顺序访问其元素的列表提供了一个List接口骨架实现，这意味着元素可以按照可预测的顺序访问，如从第一个到最后一个。

以下是Java中如何使用AbstractSequentialList类的示例：

import java.util.AbstractSequentialList;
import java.util.List;
import java.util.ListIterator;
 
public class MyList extends AbstractSequentialList<Integer> {
    private int size;
 
    public MyList(int size) {
        this.size = size;
    }
 
    @Override
    public ListIterator<Integer> listIterator(int index) {
        return new ListIterator<Integer>() {
            private int currentIndex = index;
 
            @Override
            public boolean hasNext() {
                return currentIndex < size;
            }
 
            @Override
            public Integer next() {
                return currentIndex++;
            }
 
            @Override
            public boolean hasPrevious() {
                return currentIndex > 0;
            }
 
            @Override
            public Integer previous() {
                return currentIndex--;
            }
 
            @Override
            public int nextIndex() {
                return currentIndex + 1;
            }
 
            @Override
            public int previousIndex() {
                return currentIndex - 1;
            }
 
            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
 
            @Override
            public void set(Integer integer) {
                throw new UnsupportedOperationException();
            }
 
            @Override
            public void add(Integer integer) {
                throw new UnsupportedOperationException();
            }
        };
    }
 
    @Override
    public int size() {
        return size;
    }
 
    public static void main(String[] args) {
        List<Integer> list = new MyList(5);
        for (int i : list) {
            System.out.println(i);
        }
    }
}

输出结果

通过继承AbstractSequentialList类，您只需要实现listIterator和size方法，就可以提供一个顺序列表的基本实现。与从头开始实现List接口相比，这可以节省您大量的时间和代码。

使用Java中的AbstractSequentialList的优点：

减少代码重复：通过使用AbstractSequentialList类作为基类，您可以减少实现顺序列表所需编写的代码量，因为许多通用方法已经为您实现了。
一致的行为：由于AbstractSequentialList类实现了List接口中的许多方法，因此您可以确保您的实现与其他顺序列表实现（如LinkedList）具有一致的行为。