文档章节

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

o
 osc_x4h57ch8
发布于 2018/04/25 14:35
字数 3806
阅读 10
收藏 0

前言

        最开始学习数据结构的时候,链表,堆栈,队列,数组,似乎只是一堆概念,随着使用中慢慢接触,其对应的模型,功能,一个个跃到眼前,变成了复杂模型数据处理中的最重要的部分。---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); 

我们在使用中,完全不担心类型问题,直接调用就好了,而且即便真的有类型匹配的错误,在编译期就可以将其呈现出来。

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。

暂无文章

李开复谈2020年AI科学家创业。道翰天琼认知智能api机器人接口。

2012年至今,在深度学习推动下,这一波人工智能的蓬勃发展已进入第十个年头。 在初期,一系列由AI科学家创建的初创公司,经过大浪淘沙,如今已有多家脱颖而出成为独角兽企业;榜样在先,于是...

jackli2020
13分钟前
9
0
什么是PHP中的线程安全或非线程安全? - What is thread safe or non-thread safe in PHP?

问题: I saw different binaries for PHP, like non-thread or thread safe? 我看到了PHP的不同二进制文件,例如非线程还是线程安全的? What does this mean? 这是什么意思? What is the ...

fyin1314
27分钟前
26
0
移动社交如何玩?网易云信携手崽崽和Uki打造更多新场景!

随着95后、00后为主的年轻一代逐渐成为中国移动社交下的主力军,社交需求也发生了一些变化。这些年轻用户更倾向于有趣好玩,形式多样化的社交方式。同时也产生了如“扩列”、“养火花”等众多...

真正稳定的网易云信
33分钟前
22
0
如何在Java代码中去掉烦人的“!=null”

问题 为了避免空指针调用,我们经常会看到这样的语句 if (someobject != null) { someobject.doCalc();} 最终,项目中会存在大量判空代码,多么丑陋繁冗!如何避免这种情况?我们是否滥...

码农突围
34分钟前
21
0
ELK使用容器集成安装

ELK使用容器集成安装 1. 查看集成ELK:sebp docker search sebp 2. 设置内核参数 sysctl -w vm.max_map_count=262144 3. 拉取sebp/elk docker pull sebp/elk 4. 运行ELK yum install -y java......

huanke
44分钟前
17
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部