前言
最开始学习数据结构的时候，链表，堆栈，队列，数组，似乎只是一堆概念，随着使用中慢慢接触，其对应的模型，功能，一个个跃到眼前，变成了复杂模型数据处理中的最重要的部分。---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[Index: Integer]: 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[Index: Integer]: 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[Index: Integer]: string read GetName;
property KeyNames[Index: Integer]: string read GetKeyName;
property Values[const Name: string]: string read GetValue write SetValue;
property ValueFromIndex[Index: Integer]: string read GetValueFromIndex write SetValueFromIndex;
这使得其功能和扩展性都显得极为强大，TStrings是个抽象类，而TStringList增加了Sort方法和对象耦合属性OwnsObjects。 当没有使用对象和字典配对的时候，TStringList看起来就象一个简单的字串数组。
e，TClassList
这个类似乎不需要额外谈的，类中类的列表形态，批量处理的情景除非是特别复杂的模型才可以用到。其继承类是TList，没有对象管理的拥有者功能。
2，泛型
泛型的出现，直接弄得各种List似乎都变成了一种兼容的特例模式了。泛型的可以选择任何类型的数据元素，并可以以任何数据结构模式进行组合。虽然在数据定义阶段略显复杂，但是作为一种强力的数据扩展
可以应用的场景也多得多。
泛型的引用单元：Generics.Collections，泛型的定义模式：
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[Index: Integer]: 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[ADataSetNo] is TDataSet then
funxxx(AllDataSets.Items[ADataSetNo] as TDataSet);
这不仅仅意味着要承受各种非规则数据的干扰，还必须进行强制类型转换，才能完成其初期设计的【数据集列表】这样的概念。反观泛型就要简单得多：
定义：AllDataSets : TObjectList<TDataSet>;
AllDataSets := TObjectList<TDataSet>.Create(False);
AllDataSets.Add(ADataSet);
我们在使用中，完全不担心类型问题，直接调用就好了，而且即便真的有类型匹配的错误，在编译期就可以将其呈现出来。