當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文


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);
        }
    }
}
輸出
0
1
2
3
4

通過擴展AbstractSequentialList類,您隻需要實現listIterator和size方法,它提供了順序列表的基本實現。與從頭開始實現 List 接口相比,這可以節省大量時間和代碼。

在Java中使用AbstractSequentialList的優點:

  1. 減少代碼重複:通過使用 AbstractSequentialList 類作為基礎,您可以減少實現順序列表所需編寫的代碼量,因為許多常見方法已經為您實現。
  2. 一致的行為:由於 AbstractSequentialList 類實現了 List 接口中的許多方法,因此您可以確保您的實現將與其他順序列表實現(例如 LinkedList)具有一致的行為。

在Java中使用AbstractSequentialList的缺點:

  1. 函數有限:由於 AbstractSequentialList 類是一個抽象類,因此它僅提供順序列表的基本實現。您可能需要實現其他方法來提供應用程序所需的完整函數。
  2. 增加複雜性:通過擴展“AbstractSequential”

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



相關用法


注:本文由純淨天空篩選整理自RishabhPrabhu大神的英文原創作品 AbstractSequentialList in Java with Examples。非經特殊聲明,原始代碼版權歸原作者所有,本譯文未經允許或授權,請勿轉載或複製。