Spring 框架中集合、列表與列舉的應用

– 9 分鐘閱讀

Spring 框架提供了豐富的集合型別，包括 IEnumerable<T>、ICollection<T> 和 IList<T> 等介面，以及 TEnumerable 類別，方便開發者進行資料操作。IEnumerable<T> 介面提供基本的迭代功能，ICollection<T> 介面擴充套件了集合操作，而 IList<T> 介面則提供了更精細的列表操作，例如透過索引存取元素。TEnumerable 類別提供額外的工具函式，例如 Range、Repeated 和 Empty 等，簡化常見的集合操作。理解這些介面和類別的差異，能幫助開發者選擇最合適的資料結構，提升程式碼效率。不同集合型別在存取、搜尋、插入和刪除操作上的時間複雜度各有不同，開發者需要根據實際需求選擇合適的資料結構。文章也詳細介紹了堆積疊、佇列和雙向佇列等特殊集合型別，並提供程式碼範例，說明如何在 Spring 框架中使用這些資料結構。

列舉、集合和列表

在 Spring 框架中，列舉、集合和列表是三種常見的資料結構。這些資料結構提供了不同的方法來儲存和運算元據。

列舉（IEnumerable）

列舉是一種可以遍歷的集合，允許您逐一存取其元素。Spring 框架提供了 IEnumerable<T> 介面來表示列舉。

IEnumerable<T> = interface
  function GetEnumerator: IEnumerator<T>;
end;

IEnumerable<T> 介面提供了 GetEnumerator 方法，傳回一個 IEnumerator<T> 物件，用於遍歷集合中的元素。

集合（ICollection）

集合是一種無序的元素集合，允許您新增、移除和查詢元素。Spring 框架提供了 ICollection<T> 介面來表示集合。

ICollection<T> = interface(IEnumerable<T>)
  function Add(const item: T): Boolean;
  procedure AddRange(const values: array of T);
  function Extract(const item: T): T;
  procedure Clear;
  function CopyTo(var values: TArray<T>; index: Integer): Integer;
  function MoveTo(const collection: ICollection<T>): Integer;
  function Remove(const item: T): Boolean;
  function RemoveAll(const predicate: Predicate<T>): Integer;
  property OnChanged: ICollectionChangedEvent<T> read GetOnChanged;
end;

ICollection<T> 介面提供了多種方法來操作集合，包括新增、移除、清除和複製元素。

列表（IList）

列表是一種有序的元素集合，允許您存取和操作元素。Spring 框架提供了 IList<T> 介面來表示列表。

IList<T> = interface(ICollection<T>)
  function IndexOf(const item: T): Integer;
  procedure Insert(index: Integer; const item: T);
  procedure RemoveAt(index: Integer);
  property Items[index: Integer]: T read GetItem write SetItem;
end;

IList<T> 介面提供了多種方法來操作列表，包括存取和修改元素。

示例

以下示例展示瞭如何使用 IEnumerable<T>、ICollection<T> 和 IList<T> 介面：

var
  list: IList<Integer>;
begin
  list := IList<Integer>.Create;
  list.Add(1);
  list.Add(2);
  list.Add(3);
  
  // 使用 IEnumerable<T> 遍歷集合
  for item in list do
    Writeln(item);
  
  // 使用 ICollection<T> 新增和移除元素
  list.Add(4);
  list.Remove(2);
  
  // 使用 IList<T> 存取和修改元素
  Writeln(list[0]); // 輸出：1
  list[0] := 10;
  Writeln(list[0]); // 輸出：10
end;

這個示例展示瞭如何使用不同的介面來操作集合和列表。

列表和集合的使用

在 Spring 中，列表和集合是非常重要的資料結構。這些資料結構可以用來儲存和管理大量的資料。下面，我們將介紹如何使用 Spring 的列表和集合。

列表

Spring 的列表是實作了 IList<T> 介面的類別。列表可以儲存多個元素，並且可以對元素進行增加、刪除、修改等操作。

var
  list: IList<integer>;
begin
  list := TCollections.CreateList<integer>;
  list.Add(1);
  list.Add(2);
  list.Add(3);
  ListBox1.Items.Add('List: ' + Join(' ', list.ToArray));
end;

排序列表

排序列表是實作了 IList<T> 介面的類別，並且可以自動排序元素。排序列表可以用來儲存需要排序的資料。

var
  sortedList: IList<integer>;
begin
  sortedList := TCollections.CreateSortedList<integer>;
  sortedList.Add(3);
  sortedList.Add(1);
  sortedList.Add(2);
  ListBox1.Items.Add('Sorted List: ' + Join(' ', sortedList.ToArray));
end;

字典

字典是實作了 IDictionary<TKey, TValue> 介面的類別。字典可以儲存鍵值對，並且可以用鍵來查詢值。

var
  dictionary: IDictionary<string, integer>;
begin
  dictionary := TCollections.CreateDictionary<string, integer>;
  dictionary.Add('one', 1);
  dictionary.Add('two', 2);
  ListBox1.Items.Add('Dictionary: ' + dictionary['one'].ToString);
end;

集合

集合是實作了 ISet<T> 介面的類別。集合可以儲存唯一的元素，並且可以用來查詢元素是否存在於集合中。

var
  set: ISet<integer>;
begin
  set := TCollections.CreateSet<integer>;
  set.Add(1);
  set.Add(2);
  set.Add(2);
  ListBox1.Items.Add('Set: ' + Join(' ', set.ToArray));
end;

堆積疊和佇列

堆積疊和佇列是實作了 IStack<T> 和 IQueue<T> 介面的類別。堆積疊是後進先出的資料結構，佇列是先進先出的資料結構。

var
  stack: IStack<integer>;
  queue: IQueue<integer>;
begin
  stack := TCollections.CreateStack<integer>;
  stack.Push(1);
  stack.Push(2);
  ListBox1.Items.Add('Stack: ' + stack.Pop.ToString);

  queue := TCollections.CreateQueue<integer>;
  queue.Enqueue(1);
  queue.Enqueue(2);
  ListBox1.Items.Add('Queue: ' + queue.Dequeue.ToString);
end;

雙端佇列

雙端佇列是實作了 IDeque<T> 介面的類別。雙端佇列可以在兩端增加和刪除元素。

var
  deque: IDeque<integer>;
begin
  deque := TCollections.CreateDeque<integer>;
  deque.AddFirst(1);
  deque.AddLast(2);
  ListBox1.Items.Add('Deque: ' + Join(' ', deque.ToArray));
end;

時間複雜度

下面是 Spring 集合的時間複雜度：

集合存取搜尋插入刪除
列表O(1)O(n)O(n)O(n)
排序列表O(1)O(log n)O(log n)O(n)
字典O(1)O(1)O(1)O(1)
集合O(1)O(1)O(1)O(1)
堆積疊O(1)O(n)O(1)O(1)
佇列O(1)O(n)O(1)O(1)
雙端佇列O(1)O(n)O(1)O(1)

注意：時間複雜度可能會根據具體情況而有所不同。

TEnumerable 類別

在探索其他資料結構之前，我們需要先了解 TEnumerable 類別。TEnumerable 類別實作了一些有用的操作，包括重複的操作和不在 IEnumerable 介面中的操作。以下是 TEnumerable 類別的精簡版本，包含了一些有趣的功能：

TEnumerable = class
  class function Chunk<T>(const source: IEnumerable<T>; size: Integer): IEnumerable<TArray<T>>;
  class function Distinct<T>(const source: IEnumerable<T>): IEnumerable<T>;
  class function DistinctBy<T, TKey>(const source: IEnumerable<T>; const keySelector: Func<T, TKey>): IEnumerable<T>;
  class function Empty<T>: IReadOnlyList<T>;
  class function From<T>(const values: array of T): IReadOnlyList<T>;
  class function Intersect<T>(const first, second: IEnumerable<T>): IEnumerable<T>;
  class function Range(start, count: Integer): IReadOnlyList<Integer>;
  class function Repeated<T>(const element: T; count: Integer): IEnumerable<T>;
  class function Select<T, TResult>(const source: IEnumerable<T>; const selector: Func<T, TResult>): IEnumerable<TResult>;
  class function Union<T>(const first, second: IEnumerable<T>): IEnumerable<T>;
end;

已經使用過的 Range 函式可以用於產生一系列數字。Repeated 函式可以重複一個元素，Empty 函式可以傳回一個空的唯讀列表。

##範例程式 以下是使用 TEnumerable 類別的範例程式：

procedure TfrmTEnumerable.btnTEnumerable1Click(Sender: TObject);
var
  list: TList<Integer>;
begin
  list := TList<Integer>.Create(TEnumerable.Range(11, 9).ToArray);
  ListBox1.Items.Add('Range(11,9): ' + Join(' ', TEnumerable.From<Integer>(list)));
  list.Free;
end;

在這個範例中，使用 TEnumerable.Range 函式產生了一系列數字，然後使用 TEnumerable.From 函式將 Delphi 的 TList 物件轉換為 Spring 的 IEnumerable 介面。

Join 函式

Join 函式可以用於將一個集合轉換為一個字串。以下是 Join 函式的實作：

function TfrmTEnumerable.Join(const delim: string; const enum: IEnumerable<Integer>): string;
begin
  Result := string.Join(delim, TEnumerable.Select<Integer, string>(enum, IntToString).ToArray);
end;

function TfrmTEnumerable.IntToString(const val: Integer): string;
begin
  Result := IntToStr(val);
end;

在這個實作中，使用 TEnumerable.Select 函式將集合轉換為一個字串集合，然後使用 string.Join 函式將字串集合轉換為一個單一的字串。

堆積疊和佇列

Spring 集合實作了三種基礎的集合型別：堆積疊（LIFO）、佇列（FIFO）和雙端佇列（deque）。雖然佇列和堆積疊通常使用連結串列實作，但 Spring 集合使用動態陣列實作。這種方法更快，因為不需要頻繁地分配小的記憶體塊。

堆積疊和佇列介紹

堆積疊（Stack）和佇列（Queue）是兩種基本的資料結構，常用於管理和操作資料。

堆積疊（Stack）

堆積疊是一種後進先出的資料結構，意思是最後加入的資料最先被取出。堆積疊的基本操作包括：

  • Push：加入資料到堆積疊的頂部
  • Pop：取出堆積疊頂部的資料
  • Peek：檢視堆積疊頂部的資料而不取出

堆積疊可以用陣列或連結串列實作。Spring 框架提供了 IStack<T> 介面來實作堆積疊，該介面包含了 Push、Pop、Peek 等方法。

佇列（Queue）

佇列是一種先進先出的資料結構，意思是最先加入的資料最先被取出。佇列的基本操作包括：

  • Enqueue：加入資料到佇列的尾部
  • Dequeue：取出佇列頭部的資料
  • Peek：檢視佇列頭部的資料而不取出

佇列可以用陣列或連結串列實作。Spring 框架提供了 IQueue<T> 介面來實作佇列，該介面包含了 Enqueue、Dequeue、Peek 等方法。

Spring 的實作

Spring 框架提供了 IStack<T> 和 IQueue<T> 介面來實作堆積疊和佇列。這些介面包含了基本的操作方法，例如 Push、Pop、Peek 等。

Spring 的堆積疊和佇列實作提供了多種工廠方法來建立堆積疊和佇列例項，例如 CreateStack<T> 和 CreateQueue<T>。

範例程式

以下是使用 Spring 框架的 IStack<T> 介面實作的一個簡單堆積疊範例：

var
  stack: IStack<string>;
  ch: char;
  s: string;
begin
  stack := TCollections.CreateStack<string>;
  
  for ch := '1' to '7' do
    stack.Push(ch);
  
  ListBox1.Items.Add('Stack: ' + ''.Join(' ', stack.ToArray));
  
  s := 'Stack remove: ';
  while not stack.IsEmpty do
    s := s + stack.Pop + ' ';
  
  ListBox1.Items.Add(s);
end;

這個範例建立了一個字串堆積疊，然後將字元 ‘1’ 到 ‘7’ 推入堆積疊。接著，它將堆積疊的內容加入到列表框中，然後將所有字串從堆積疊中彈出並加入到列表框中。

介紹資料結構中的Queue

Queue是一種先進先出的資料結構，元素從尾部加入，從頭部移除。Spring框架中實作了三種Queue變體：正常Queue、有界Queue和逐出Queue。

Queue介面

Queue介面定義了以下方法：

  • Clear: 清除Queue中的所有元素
  • Enqueue(const item: T): Boolean: 將元素加入Queue尾部
  • Dequeue: T: 移除Queue頭部的元素
  • Extract: T: 移除Queue頭部的元素
  • Peek: T: 檢視Queue頭部的元素
  • PeekOrDefault: T: 檢視Queue頭部的元素，如果Queue為空則傳回預設值
  • TryDequeue(var item: T): Boolean: 嘗試移除Queue頭部的元素
  • TryExtract(var item: T): Boolean: 嘗試移除Queue頭部的元素
  • TryPeek(var item: T): Boolean: 嘗試檢視Queue頭部的元素
  • TrimExcess: 刪除Queue中多餘的空間

Queue的種類

Spring框架中實作了三種Queue變體：

  • 正常Queue：無大小限制
  • 有界Queue：有大小限制，當Queue滿時，新加入的元素會被丟棄
  • 逐出Queue：有大小限制，當Queue滿時，Queue頭部的元素會被丟棄

Queue的使用

Queue可以使用以下方法進行操作：

// 建立一個Queue
queue := TCollections.CreateQueue<string>;

// 將元素加入Queue尾部
for ch := '1' to '7' do
  queue.Enqueue(ch);

// 檢視Queue頭部的元素
s := 'Queue remove: ';
while not queue.IsEmpty do
  s := s + queue.Dequeue + ' ';

// 刪除Queue中多餘的空間
queue.TrimExcess;

有界Queue和逐出Queue的使用

有界Queue和逐出Queue可以使用以下方法進行操作：

// 建立一個有界Queue
queue := TCollections.CreateBoundedQueue<string>(5);

// 將元素加入Queue尾部
for ch := '1' to '7' do
  queue.Enqueue(ch);

// 檢視Queue頭部的元素
ListBox1.Items.Add('BoundedQueue: ' + ''.Join(' ', queue.ToArray));

// 建立一個逐出Queue
queue := TCollections.CreateEvictingQueue<string>(5);

// 將元素加入Queue尾部
for ch := '1' to '7' do
  queue.Enqueue(ch);

// 檢視Queue頭部的元素
ListBox1.Items.Add('EvictingQueue: ' + ''.Join(' ', queue.ToArray));

雙向佇列（Deque）概述

雙向佇列（Deque）是一種可以在兩端新增和移除元素的集合。它類似於佇列，但提供了更多的操作方式。下面是 Spring 中的 IDeque<T> 介面定義：

IDeque<T> = interface(IEnumerable<T>)
  procedure Clear;
  function AddFirst(const item: T): Boolean;
  function AddLast(const item: T): Boolean;
  function RemoveFirst: T;
  function RemoveLast: T;
  function ExtractFirst: T;
  function ExtractLast: T;
  function TryRemoveFirst(var item: T): Boolean;
  function TryRemoveLast(var item: T): Boolean;
  function TryExtractFirst(var item: T): Boolean;
  function TryExtractLast(var item: T): Boolean;
  procedure TrimExcess;
  property Capacity: Integer read GetCapacity write SetCapacity;
  property OnChanged: ICollectionChangedEvent<T> read GetOnChanged;
end;

這個介面提供了多種方法來操作雙向佇列，包括新增和移除元素、清空集合、以及取得集合的容量和變化事件。

雙向佇列的實作

Spring 提供了三種不同的雙向佇列實作：正常的雙向佇列、有界的雙向佇列和逐出式的雙向佇列。這些實作可以透過工廠方法來建立：

class function CreateDeque<T>: IDeque<T>;
class function CreateBoundedDeque<T>(size: Integer): IDeque<T>;
class function CreateEvictingDeque<T>(size: Integer): IDeque<T>;

正常的雙向佇列的大小不受限制，而有界的雙向佇列和逐出式的雙向佇列則有最大大小限制。當有界的雙向佇列達到最大大小時，新的元素將被丟棄；而逐出式的雙向佇列則會移除另一端的元素。

從資料結構的底層實作到高階應用，本文全面檢視了 Spring 框架中列舉、集合、列表、堆積疊、佇列和雙向佇列等關鍵資料結構。藉由程式碼範例和介面定義的解析，我們深入探討了IEnumerable<T>、ICollection<T>、IList<T>、IStack<T>、IQueue<T>和IDeque<T>等核心介面的使用方法，以及TEnumerable類別提供的擴充功能，例如Range、Repeated和Empty等函式，更有助於開發者靈活運用這些資料結構。分析不同資料結構的特性，例如列表的有序性、集合的唯一性以及堆積疊和佇列的先進先出/後進先出特性，可以幫助開發者根據實際需求選擇合適的資料結構，並藉由理解其時間複雜度，進一步提升程式效能。然而，Spring 集合使用動態陣列實作堆積疊和佇列，雖然在效能上有所提升，但也需要開發者注意動態陣列擴充的潛在效能損耗。展望未來，隨著 Spring 框架的持續發展，預期會有更多針對特定應用場景的資料結構和演算法最佳化出現，例如更有效率的排序演算法和更靈活的集合操作。對於追求效能的開發者而言，深入理解 Spring 框架提供的各種資料結構和其底層實作原理，並根據應用場景選擇最合適的資料結構，將是提升應用程式效能的關鍵。玄貓認為，開發者應深入研究TEnumerable類別，善用其提供的擴充功能，以簡化程式碼並提升開發效率。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。