看看Delphi中的列表(List)和泛型

升虹小哥 發表於 2020-8-15 14:19:00

前言
        最开始学习数据结构的时候，链表，堆栈，队列，数组，似乎只是一堆概念，随着使用中慢慢接触，其对应的模型，功能，一个个跃到眼前，变成了复杂模型数据处理中的最重要的部分。---By Murphy 20180424
1，列表
Delphi中的列表有很多，从数据结构上可以分作：TList(数据链)，TQueue(队列)，TStack(堆栈)，TDictionary(字典表)等等；而从功能上又可以分作TList(列表),TObjectList(对象列表),TComponentList(组件列表),TStringList(字串列表),TClassList(类列表)。
列表的数据结构性，决定了列表的基础方法，基本都是以增删改查，计数，排序为主；而功能列表中，进一步增强了对每个节点元素的检查和限制，从而增加了针对这种数据类型的更贴合的功能，例如：对象的自动销毁，或仅结构移除，构建排序比较规则等等。现在就让我们看几种具有代表性的列表
a,TList
我们首先来看看TList在DelphiRX10中的源码定义
  TList = class(TObject)   private     FList: TPointerList;          FCount: Integer;     FCapacity: Integer;   protected     function Get(Index: Integer): Pointer;     procedure Grow; virtual;     procedure Put(Index: Integer; Item: Pointer);     procedure Notify(Ptr: Pointer; Action: TListNotification); virtual;     procedure SetCapacity(NewCapacity: Integer);     procedure SetCount(NewCount: Integer);   public     type       TDirection = System.Types.TDirection;
    destructor Destroy; override;     function Add(Item: Pointer): Integer;                                                                               //添加一个新元素     procedure Clear; virtual;                                                                                                  //清空列表     procedure Delete(Index: Integer);                                                                                    //删除对象元素并销毁     class procedure Error(const Msg: string; Data: NativeInt); overload; virtual;     class procedure Error(Msg: PResStringRec; Data: NativeInt); overload;     procedure Exchange(Index1, Index2: Integer);                                                                //交换对象     function Expand: TList;                                                                                                     //扩展当前对象容量     function Extract(Item: Pointer): Pointer; inline;                                                                  //移除对象元素，而不是销毁，并且返回对象指针     function ExtractItem(Item: Pointer; Direction: TDirection): Pointer;                                   //从当前对象指针开始定向定位，查找到对应对象并移除       function First: Pointer; inline;                                                                                             //当前对象指针移动到第一个元素     function GetEnumerator: TListEnumerator;                                                                       //一个抽象列表，没看懂这里的扩展性设计     function IndexOf(Item: Pointer): Integer;                                                                           //检索元素     function IndexOfItem(Item: Pointer; Direction: TDirection): Integer;     procedure Insert(Index: Integer; Item: Pointer);                                                                //插入一个对象元素     function Last: Pointer;                                                                                                       //当前对象指针移动到最后一个元素上     procedure Move(CurIndex, NewIndex: Integer);                                                              //将当前对象移动位置     function Remove(Item: Pointer): Integer; inline;                                                               //移除对象     function RemoveItem(Item: Pointer; Direction: TDirection): Integer;     procedure Pack;                                                                                                               //清空空对象
   //TListSortCompare = function (Item1, Item2: Pointer): Integer;    //TListSortCompareFunc = reference to function (Item1, Item2: Pointer): Integer;     procedure Sort(Compare: TListSortCompare);                                                                //排序函数,这里TListSortCompare对应的是排序函数的指针     procedure SortList(const Compare: TListSortCompareFunc);                                         //TListSortCompareFunc是对应TListSortCompare的匿名函数，方法定义更为灵活     procedure Assign(ListA: TList; AOperator: TListAssignOp = laCopy; ListB: TList = nil);  //指定内容来源     property Capacity: Integer read FCapacity write SetCapacity;                                         //空间计数     property Count: Integer read FCount write SetCount;                                                      //元素计数     property Items: Pointer read Get write Put; default;     property List: TPointerList read FList;                                                                              //指针列表   end
我们可以看到，这个TList算所有列表之源，具备了所有列表类型的基础方法属性。
b, TObjectList
这种List的单元Contnrs需要额外引用一下，我们在这个类的源码中可以看到，几乎所有的方法名跟TList都是一致的，只不过元素对象参数由TPoint变成了TObject，另外，还增加了以下两个新的方法：
    constructor Create(AOwnsObjects: Boolean); overload;       //重载了一个构造方法，这里可以在创建的时候直接指定其拥有者，如果是False，就跟TList差别很大了，相当于这个ObjectList是独立于元素存在的。
                                                                                                  //这时候元素的空间需要额外的管理
    property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;   //这个是ObjectList的一个属性，可以由构造方法带进来，也可以使用时改变。
c，TComponetList
这个是直接继承TObjectList的，同样的，所有元素由基础对象改成了组件。但是这个类中也增加了一个方法：
     procedure HandleFreeNotify(Sender: TObject; AComponent: TComponent);            //这个方法对应着procedure TComponent.FreeNotification(AComponent: TComponent);方法
这个方法使得其管理的对象释放更为灵活，释放一个元素组件的时候，不需要操作ComponentList ,可以直接操作元素，并通过元素组件的方法自动触发TComponentList来处理链结构。
 
d，TStringList
TStringList跟TList并不是一脉相承的，而是继承TStrings的，而TStrings是继承TPersistent的，其方法完全是为字串服务的，跟TList有相似点，其变化又比TList系列更为复杂。因为其具备
一系列增加和管理对象的方法:
property Objects: TObject read GetObject write PutObject;
function AddObject(const S: string; AObject: TObject): Integer; virtual;
function IndexOfObject(AObject: TObject): Integer; virtual;
procedure InsertObject(Index: Integer; const S: string; AObject: TObject); virtual;
function ToObjectArray: TArray<TObject>;
除此之外，还具备字典配对的功能:
     property Names: string read GetName;
    property KeyNames: string read GetKeyName;
    property Values: string read GetValue write SetValue;     property ValueFromIndex: string read GetValueFromIndex write SetValueFromIndex;
这使得其功能和扩展性都显得极为强大，TStrings是个抽象类，而TStringList增加了Sort方法和对象耦合属性OwnsObjects。当没有使用对象和字典配对的时候，TStringList看起来就象一个简单的字串数组。
e，TClassList
这个类似乎不需要额外谈的，类中类的列表形态，批量处理的情景除非是特别复杂的模型才可以用到。其继承类是TList，没有对象管理的拥有者功能。
 
2，泛型
泛型的出现，直接弄得各种List似乎都变成了一种兼容的特例模式了。泛型的可以选择任何类型的数据元素，并可以以任何数据结构模式进行组合。虽然在数据定义阶段略显复杂，但是作为一种强力的数据扩展
可以应用的场景也多得多。
泛型的引用单元：Generics.Collections，泛型的定义模式：
<img src="https://img2020.cnblogs.com/blog/1107379/202008/1107379-20200815141805554-928114615.png" alt="" loading="lazy">
 
 
<div id="cnblogs_post_body" class="blogpost-body">
a，泛型数据类型的构成基础
我们先来看看泛型单元中的前四个数据定义，他们是泛型构成的基础件:TArray(TObject)，TEnumerator<T>(TObject)，TEnumerable<T>(TObject)，TListHelper(TObject)
  TArray = class   private     class procedure QuickSort<T>(var Values: array of T; const Comparer: IComparer<T>;       L, R: Integer); static;     class procedure CheckArrays(Source, Destination: Pointer; SourceIndex, SourceLength, DestIndex, DestLength, Count: NativeInt); static;   public     class procedure Sort<T>(var Values: array of T); overload; static;     class procedure Sort<T>(var Values: array of T; const Comparer: IComparer<T>); overload; static;     class procedure Sort<T>(var Values: array of T;       const Comparer: IComparer<T>; Index, Count: Integer); overload; static;
    class function BinarySearch<T>(const Values: array of T; const Item: T;       out FoundIndex: Integer; const Comparer: IComparer<T>;       Index, Count: Integer): Boolean; overload; static;     class function BinarySearch<T>(const Values: array of T; const Item: T;       out FoundIndex: Integer; const Comparer: IComparer<T>): Boolean; overload; static;     class function BinarySearch<T>(const Values: array of T; const Item: T;       out FoundIndex: Integer): Boolean; overload; static; static;
    class procedure Copy<T>(const Source: array of T; var Destination: array of T; SourceIndex, DestIndex, Count: NativeInt); overload; static;     class procedure Copy<T>(const Source: array of T; var Destination: array of T; Count: NativeInt); overload; static;   end;
这是额外为TArray定义的一段代码，本人看得不是特别懂，感觉这个主要的功能是为System中的TArray<T>定义作一个扩展。
注意，TArray<T>的定义是出现在System单元中：TArray<T> = array of T;
这个TArray扩展为后续的泛型定义，提供了一个本体。接下来，我们看看两个抽象类:TEnumerator<T>,TEnumerable<T>.
  TEnumerator<T> = class abstract   protected     function DoGetCurrent: T; virtual; abstract;     function DoMoveNext: Boolean; virtual; abstract;   public     property Current: T read DoGetCurrent;     function MoveNext: Boolean;   end;
 
  TEnumerable<T> = class abstract   private   {$HINTS OFF}     function ToArrayImpl(Count: Integer): TArray<T>; // used by descendants   {$HINTS ON}   protected     function DoGetEnumerator: TEnumerator<T>; virtual; abstract;   public     destructor Destroy; override;     function GetEnumerator: TEnumerator<T>;     function ToArray: TArray<T>; virtual;   end;
这两个抽象类，TEnumerable是所有泛型的基类，定义出泛型的数据实体是TArray<T>模式，并且引用了另外一个抽象方法类TEnumerator ,使得泛型具备获取当前元素Current以及MoveNext导航功能。
这个设计很重要，我们可以看到Current和MoveNext在这里不再是数据结构的属性，而是作为元素基础功能出现的。
最后，我们再来看看一个附加的结构体：TListHelper = record ，它十分复杂，我没有太多时间去详细研究，暂时看到它是作为泛型的扩展属性使用的，所以就认为它是一个泛型的帮助信息扩展吧。
b，TList<T>
这个类型的篇幅还是比较长的，比TList要复杂多了，既融合了TList的基础定义，又加入了泛型的实现基础，下面我们一起看一看其定义的过程。
  TList<T> = class(TEnumerable<T>)   private type     arrayofT = array of T;                                                                                           //定义了一个内部元数组类   var     FListHelper: TListHelper; // FListHelper must always be followed by FItems     //暂且认为是帮助信息类，不做过多分析     FItems: arrayofT; // FItems must always be preceded by FListHelper                //利用元数组类实现了一个元数据实体     FComparer: IComparer<T>;                                                                               //为排序而诞生的比较方法指针     FOnNotify: TCollectionNotifyEvent<T>;                                                             //内部事件
    function GetCapacity: Integer; inline;                                                                 //得到整个泛型的内存空间     procedure SetCapacity(Value: Integer); overload; inline;                                  //动态设置元素的Length     procedure SetCount(Value: Integer); inline;                                                      //动态设置元素个数     function GetItem(Index: Integer): T; inline;                                                        //根据序号获得指定元素     procedure SetItem(Index: Integer; const Value: T); inline;      procedure GrowCheck(ACount: Integer); inline;                                              //Helper相关     procedure DoDelete(Index: Integer; Notification: TCollectionNotification); inline;      //根据序号删除并销毁某元素     procedure InternalNotify(const Item; Action: TCollectionNotification);                            function InternalCompare(const Left, Right): Integer;     property FCount: Integer read FListHelper.FCount write FListHelper.FCount;   protected     function ItemValue(const Item: T): NativeInt;                                                 //返回元素的值，NativeInt是内存中一种Int编码值。     function DoGetEnumerator: TEnumerator<T>; override;                               //重新构建元素的导航功能。     procedure Notify(const Item: T; Action: TCollectionNotification); virtual;   public   type     TDirection = System.Types.TDirection;                                                        //定义方向，用于List的定向操作     TEmptyFunc = reference to function (const L, R: T): Boolean;                    //为空时的匿名函数     TListCompareFunc = reference to function (const L, R: T): Integer;            //为排序比较时的匿名函数
   //再往下看基本就没什么新方法了，功能都是结合TList和TEnumerable的功能重组.
   constructor Create; overload;     constructor Create(const AComparer: IComparer<T>); overload;     constructor Create(const Collection: TEnumerable<T>); overload;     destructor Destroy; override;
    class procedure Error(const Msg: string; Data: NativeInt); overload; virtual; {$IFNDEF NEXTGEN}     class procedure Error(Msg: PResStringRec; Data: NativeInt); overload; {$ENDIF  NEXTGEN}
    function Add(const Value: T): Integer; inline;
    procedure AddRange(const Values: array of T); overload;     procedure AddRange(const Collection: IEnumerable<T>); overload; inline;     procedure AddRange(const Collection: TEnumerable<T>); overload; inline;
    procedure Insert(Index: Integer; const Value: T); inline;
    procedure InsertRange(Index: Integer; const Values: array of T); overload;     procedure InsertRange(Index: Integer; const Collection: IEnumerable<T>); overload;     procedure InsertRange(Index: Integer; const Collection: TEnumerable<T>); overload;
    procedure Pack; overload;     procedure Pack(const IsEmpty: TEmptyFunc); overload;
    function Remove(const Value: T): Integer; inline;     function RemoveItem(const Value: T; Direction: TDirection): Integer; inline;     procedure Delete(Index: Integer); inline;     procedure DeleteRange(AIndex, ACount: Integer); inline;     function ExtractItem(const Value: T; Direction: TDirection): T; inline;     function Extract(const Value: T): T; inline;
    procedure Exchange(Index1, Index2: Integer); inline;     procedure Move(CurIndex, NewIndex: Integer); inline;
    function First: T; inline;     function Last: T; inline;
    procedure Clear; inline;
    function Expand: TList<T>; inline;
    function Contains(const Value: T): Boolean; inline;     function IndexOf(const Value: T): Integer; inline;     function IndexOfItem(const Value: T; Direction: TDirection): Integer; inline;     function LastIndexOf(const Value: T): Integer; inline;
    procedure Reverse; inline;
    procedure Sort; overload;     procedure Sort(const AComparer: IComparer<T>); overload;     function BinarySearch(const Item: T; out Index: Integer): Boolean; overload;     function BinarySearch(const Item: T; out Index: Integer; const AComparer: IComparer<T>): Boolean; overload;
    procedure TrimExcess; inline;
    function ToArray: TArray<T>; override; final;
    property Capacity: Integer read GetCapacity write SetCapacity;     property Count: Integer read FListHelper.FCount write SetCount;     property Items: T read GetItem write SetItem; default;     property List: arrayofT read FItems;
    property OnNotify: TCollectionNotifyEvent<T> read FOnNotify write FOnNotify;
    type                                                                                                         //这里重新指定了元素导航的功能实现       TEnumerator = class(TEnumerator<T>)       private         FList: TList<T>;         FIndex: Integer;         function GetCurrent: T;       protected         function DoGetCurrent: T; override;         function DoMoveNext: Boolean; override;       public         constructor Create(const AList: TList<T>);         property Current: T read GetCurrent;         function MoveNext: Boolean;       end;
    function GetEnumerator: TEnumerator; reintroduce; inline;   end;
该类应该是泛型中使用最为广泛的一个类，我们既可以用以后的类来组合使用，又可以重新定义其各项基础功能实现扩展。
直接使用的模式： DataSetList: TList<TDataSet>;
重新定义的模式：
type
      TSpecList<T>=class(TList<T>)
     ....
end;
使用的时候直接将<T>实化：DataSetList: TSpecList<TDataSet>;
c，其他几种使用频率比较高的泛型：
TQueue<T> = class(TEnumerable<T>)                           //队列泛型，定义几乎跟TList<T> 一样，所以这里的方法说明省去。
TThreadList<T> = class                                                   //线程泛型，实体是TList<T>，针对其控制增加了锁定方法。
TStack<T> = class(TEnumerable<T>)                            //堆栈泛型，增加了Pop和Push方法，其他定义几乎跟TList<T>一致。
  TPair<TKey,TValue> = record     Key: TKey;     Value: TValue;     constructor Create(const AKey: TKey; const AValue: TValue);   end;   TDictionary<TKey,TValue> = class(TEnumerable<TPair<TKey,TValue>>)      //字典泛型，这个比较有用，数据是以Key和Value成对出现。主要是增加了Hash方法，各种元素操作也都以Key作为参数。
这些泛型都是基于数据结构的变化。
 
d，与对象相关的泛型扩展 TObjectList<T>,
TObjectList<T: class> = class(TList<T>)   
  private     FOwnsObjects: Boolean;   protected     procedure Notify(const Value: T; Action: TCollectionNotification); override;   public     constructor Create(AOwnsObjects: Boolean = True); overload;     constructor Create(const AComparer: IComparer<T>; AOwnsObjects: Boolean = True); overload;     constructor Create(const Collection: TEnumerable<T>; AOwnsObjects: Boolean = True); overload;     destructor Destroy; override;     property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;                                         //主要就是增加了这个属性，让其元素耦合性降低   end;
TObjectQueue<T: class> = class(TQueue<T>)
TObjectStack<T: class> = class(TStack<T>)
TObjectDictionary<TKey,TValue> = class(TDictionary<TKey,TValue>)
以上这四种泛型都是在原有泛型上的轻微扩展，同列表的对象扩展一样。最主要的属性就是OwnsObjects，使得整个泛型数据集，可以拥有对象空间的独立管理能力。
 
3，小结
为什么我们要使用泛型？泛型数据的优势和劣势又各是什么呢？
其实Delphi引用泛型数据算比较落后的了，Java很早就有泛型概念，而FrameWork也是从2.0 开始就引入了泛型数据，而Delphi是从Delphi2009~Delphi2010才正式引入泛型。
泛型的早期模式，其实就是各种列表，也就是本篇的第1点所阐述的内容，对比泛型和列表，其实泛型能实现的方式列表都可以实现，而列表的异构元素结构，泛型是不适合的。
那么泛型相对列表有什么优势呢？优势主要体现在两个方面：重用性，安全高效性。
a，重用性
这里举个例子说明，我们如果需要两个列表TStringxxxList，TIntxxxList，如果用列表继承的概念，那就必须要写两个定义：
type TStringList=class(TList)
...这可能会有count方法
end;
type TIntxxxList=class(TList)
...这可能会有count方法
end;
 如果换作泛型，就只需要定义一次就好了，列表中通性的方法是固定的。
type TxxxList<T>=class(TList<T>)
...这里可能有count方法
end;
使用时，我们用TxxxList<string>,TxxxList<Int>就可以取代两种List。
b，安全高效性
虽然用列表也可以实现子类型的存取，但是在使用过程中就免不了要进行类型转换和判断（装箱和拆箱），即不安全，也会影响到系统效率。
例如：
  AllDataSets : TComponentList;                                 //用List进行一个数据集的存储。
  AllDataSets := TComponentList.Create(False);        //非耦合性列表   AllDataSets.Add(ADataSet);                                   //存放一个数据集
到这一步似乎跟泛型都没什么差异，然而取的时候就比较麻烦了。
if AllDataSets.Items is TDataSet then
 funxxx(AllDataSets.Items as TDataSet);
这不仅仅意味着要承受各种非规则数据的干扰，还必须进行强制类型转换，才能完成其初期设计的【数据集列表】这样的概念。反观泛型就要简单得多：
定义：AllDataSets : TObjectList<TDataSet>;
AllDataSets := TObjectList<TDataSet>.Create(False);
AllDataSets.Add(ADataSet); 
我们在使用中，完全不担心类型问题，直接调用就好了，而且即便真的有类型匹配的错误，在编译期就可以将其呈现出来。

</div>
<div id="MySignature">不求功能强大，但求小巧融洽</div>

</div>
<div id="MySignature" role="contentinfo">
好的代码像粥一样，都是用时间熬出来的 
来源：https://www.cnblogs.com/jijm123/p/13508613.html

頁: [1]

琼殿技术论坛's Archiver

看看Delphi中的列表(List)和泛型