Java AbstractSequentialList用法及代码示例

AbstractSequentialListJava 中的类是Java集合框架并实施采集接口和AbstractCollection 类。它用于实现一个不可修改的列表，只需扩展AbstractList类并仅实现get()和size()方法。

此类提供 List 接口的骨架实现，以最大限度地减少实现由 “sequential access” 数据存储(例如链接列表)支持的接口所需的工作量。对于随机访问数据(例如数组)，应优先使用AbstractList而不是此类。

类层次结构：

AbstractSequentialList-in-Java

声明：

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

Where E is the type of element maintained by this List.

它实现了可迭代<E>,集合<E>,List Interface接口。LinkedList是 AbstractSequentialList 的唯一直接子类。

构造函数：受保护AbstractSequentialList()-默认构造函数，但受保护，不允许创建 AbstractSequentialList 对象。

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

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

Java


// Java code to illustrate AbstractSequentialList
import java.util.*;
public class GfG {
    public static void main(String[] args)
    {
        // Creating an instance of
        // the AbstractSequentialList
        AbstractSequentialList<Integer> absl
            = new LinkedList<>();
        // adding elements to absl
        absl.add(5);
        absl.add(6);
        absl.add(7);
        // Printing the list
        System.out.println(absl);
    }
}

输出

[5, 6, 7]

输出：

[5, 6, 7]

示例2：

Java


// Java code to illustrate
// methods of AbstractSequentialList
import java.util.*;
import java.util.AbstractSequentialList;
public class AbstractSequentialListDemo {
    public static void main(String args[])
    {
        // Creating an empty AbstractSequentialList
        AbstractSequentialList<String>
            absqlist = new LinkedList<String>();
        // Using add() method to
          // add elements in the list
        absqlist.add("Geeks");
        absqlist.add("for");
        absqlist.add("Geeks");
        absqlist.add("10");
        absqlist.add("20");
        // Output the list
        System.out.println("AbstractSequentialList: "
                           + absqlist);
        // Remove the head using remove()
        absqlist.remove(3);
        // Print the final list
        System.out.println("Final List: "
                           + absqlist);
        // Fetching the specific 
          // element from the list
        // using get() method
        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: [Geeks, for, Geeks, 10, 20]
Final List: [Geeks, for, Geeks, 20]
The element is: Geeks

Methods of AbstractSequentialList

METHOD	DESCRIPTION
AbstractSequentialList add()	在此列表中的指定位置插入指定元素(可选操作)。
AbstractSequentialList addAll()	将指定集合中的所有元素插入到此列表的指定位置(可选操作)。
获取(整数索引)	返回此列表中指定位置的元素。
AbstractSequentialList iterator()	返回此列表中元素的迭代器(按正确的顺序)。
AbstractSequentialList ListIterator()	返回此列表中元素的列表迭代器(按正确的顺序)。
AbstractSequentialList remove()	删除此列表中指定位置的元素(可选操作)。
AbstractSequentialList set()	将此列表中指定位置的元素替换为指定元素(可选操作)。

Methods Inherited From class java.util.AbstractList

METHOD	DESCRIPTION
AbstractList add(E ele)	将指定元素追加到此列表的末尾(可选操作)。
AbstractList clear()	从此列表中删除所有元素(可选操作)。
AbstractList equals()	比较指定对象与此列表是否相等。
AbstractList hashCode()	返回此列表的哈希码值。
AbstractList indexOf()	返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1。
AbstractList lastIndexOf()	返回此列表中最后一次出现的指定元素的索引，如果此列表不包含该元素，则返回 -1。
AbstractList listIterator()	返回此列表中元素的列表迭代器(按正确的顺序)。
removeRange(int fromIndex, int toIndex)	从此列表中删除索引介于 fromIndex(包含)和 toIndex(不包含)之间的所有元素。
AbstractList subList()	返回此列表中指定的 fromIndex(包含)和 toIndex(不包含)之间的部分的视图。

从类 java.util.AbstractCollection 继承的方法

METHOD	DESCRIPTION
AbstractCollection addAll()	将指定集合中的所有元素添加到此集合中(可选操作)。
AbstractCollection contains()	如果此集合包含指定元素，则返回 true。
AbstractCollection containsAll()	如果此集合包含指定集合中的所有元素，则返回 true。
AbstractCollection isEmpty()	如果此集合不包含任何元素，则返回 true。
AbstractCollection remove()	从此集合中删除指定元素的单个实例(如果存在)(可选操作)。
AbstractCollection removeAll()	删除指定集合中也包含的所有该集合的元素(可选操作)。
AbstractCollection retainAll()	仅保留此集合中包含在指定集合中的元素(可选操作)。
AbstractCollection toArray()	返回一个包含此集合中所有元素的数组。
AbstractCollection toArray()	返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
AbstractCollection toString()	返回此集合的字符串表示形式。

Methods Inherited From Interface java.util.Collection

METHOD	DESCRIPTION
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
stream()	返回以此集合作为源的顺序 Stream。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。

Methods Inherited From Interface java.lang.Iterable

METHOD	DESCRIPTION
forEach(消费者<? super T> 操作)	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。

Methods Inherited From Interface java.util.List

METHOD	DESCRIPTION
List addAll()	将指定集合中的所有元素按它们所在的顺序附加到此列表的末尾由指定集合的迭代器返回(可选操作)。
List contains()	如果此列表包含指定元素，则返回 true。
List containsAll()	如果此列表包含指定集合的所有元素，则返回 true。
List isEmpty()	如果此列表不包含任何元素，则返回 true。
remove(Object o)	从此列表中删除第一次出现的指定元素(如果存在)(可选操作)。
List removeAll()	从此列表中删除指定集合中包含的所有元素(可选操作)。
ReplaceAll(UnaryOperator<E> 运算符)	将此列表中的每个元素替换为将运算符应用于该元素的结果。
List retainAll()	仅保留此列表中指定集合中包含的元素(可选操作)。
List size()	返回此列表中的元素数量。
排序(比较器<? super E> c)	根据指定比较器产生的顺序对此列表进行排序。
spliterator()	在此列表中的元素上创建一个 Spliterator。
toArray()	返回一个数组，其中按正确顺序(从第一个元素到最后一个元素)包含此列表中的所有元素。
toArray(T[] a)	返回一个数组，其中按正确顺序(从第一个元素到最后一个元素)包含此列表中的所有元素；返回数组的运行时类型是指定数组的运行时类型。

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

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

Java


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)具有一致的行为。

在Java中使用AbstractSequentialList的缺点：

函数有限：由于 AbstractSequentialList 类是一个抽象类，因此它仅提供顺序列表的基本实现。您可能需要实现其他方法来提供应用程序所需的完整函数。
增加复杂性：通过扩展“AbstractSequential”

参考： https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/AbstractSequentialList.html

相关用法

注：本文由纯净天空筛选整理自RishabhPrabhu大神的英文原创作品 AbstractSequentialList in Java with Examples。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。