从Delphi 5开始VCL中增加了一个新的Contnrs单元，单元中定义了８个新的类，全部都是基于
TList 类
| 属性 | 描述 |
| Count: Integer; | 返回列表中的项目数 |
| Items[Index: Integer]: Pointer; default |
| 方法 | 类型 | 描述 |
| Add(Item: Pointer): Integer; | 函数 | 用来向列表中添加指针 |
| Clear; | 过程 | 清空列表中的项目 |
| Delete(Index: Integer); | 过程 | 删除列表中对应索引的项目 |
| IndexOf(Item: Pointer): Integer; | 函数 | 返回指针在列表中的索引 |
| Insert(Index: Integer; Item: Pointer); | 过程 | 将一个项目插入到列表中的指定位置 |
| Remove(Item: Pointer): Integer; | 函数 | 从列表中删除指针 |
| 名称 | 类型 | 描述 |
| Capacity: Integer; | property | 可以用来获取或设定列表可以容纳的指针数目 |
| Extract(Item: Pointer): Pointer; | function | Extract 类似于Remove 可以将指针从列表中删除，不同的是返回被删除的指针。 |
| Exchange(Index1, Index2: Integer); | procedure | 交换列表中两个指针 |
| First: Pointer; | function | 返回链表中的第一个指针 |
| Last: Pointer; | function | 返回链表中最后一个指针 |
| Move(CurIndex NewIndex: Integer); | procedure | 将指针从当前位置移动到新的位置 |
| Pack; | procedure | 从列表中删除所有nil指针 |
| Sort(Compare: TListSortCompare); | procedure | 用来对链表中的项目进行排序，可以设定Compare参数为用户定制的排序函数 |
TObjectList 类
TObjectList 类直接从TList 类继承，可以作为对象的容器。TObjectList类定义如下：
TObjectList = class(TList)
...
public
constructor Create; overload;
constructor Create(AOwnsObjects: Boolean); overload;
function Add(AObject: TObject): Integer;
function Remove(AObject: TObject): Integer;
function IndexOf(AObject: TObject): Integer;
function FindInstanceOf(AClass: TClass;
AExact: Boolean = True; AStartAt: Integer = 0):
Integer;
procedure Insert(Index: Integer; AObject: TObject);
property OwnsObjects: Boolean;
property Items[Index: Integer]: TObject; default;
end;
不同于TList类，TObjectList类的Add, Remove, IndexOf, Insert等方法都需要传递TObject对象作为参数，由于有了编译期的强类型检查，使得TObjectList比TList更适合保存对象。此外TObjectList对象有OwnsObjects属性。当设定为True (默认值)，同TList类不同，TObjectList对象将销毁任何从列表中删除的对象。无论是调用Delete, Remove, Clear 方法，还是释放TObjectList对象，都将销毁列表中的对象。有了TObjectList类，我们就再也不用使用循环来释放了对象。这就避免了释放链表对象时，由于忘记释放链表中的对象而导致的内存泄漏。另外要注意的是OwnsObjects属性不会影响到Extract方法，TObjectList的Extract方法行为类似于TList，只是从列表中移除对象引用，而不会销毁对象。
TObjectList 对象还提供了一个FindInstanceOf 函数，可以返回只有指定对象类型的对象实例在列表中的索引。如果AExact 参数为True，只有指定对象类型的对象实例会被定位，如果AExact 对象为False，AClass 的子类实例也将被定位。AStartAt 参数可以用来找到列表中的多个实例，只要每次调用FindInstanceOf 函数时，将起始索引加１，就可以定位到下一个对象，直到FindInstanceOf 返回-1。下面是代码示意：
var
idx: Integer;
begin
idx := -1;
repeat
idx := ObjList.FindInstanceOf(TMyObject, True, idx+1);
if idx >= 0 then
...
until(idx < 0);
end;
TComponentList 类
Contnrs单元中还定义了TComponentList 类，类定义如下：
TComponentList = class(TObjectList)
...
public
function Add(AComponent: TComponent): Integer;
function Remove(AComponent: TComponent): Integer;
function IndexOf(AComponent: TComponent): Integer;
procedure Insert(Index: Integer; AComponent: TComponent);
property Items[Index: Integer]: TComponent; default;
end;
注意TComponentList 是从TObjectList类继承出来的，它的Add, Remove, IndexOf, Insert和 Items 方法调用都使用TComponent 类型的参数而不再是TObject类型，因此适合作为TComponent对象的容器。TComponentList 类还有一个特殊的特性，就是如果链表中的一个组件被释放的话，它将被自动的从TComponentList 链表中删除。这是利用TComponent的FreeNotification方法可以在组件被销毁时通知链表，这样链表就可以将对象引用从链表中删除的。
TClassList 类
Contnrs单元中还定义了TClassList类，类定义如下：
TClassList = class(TList)
protected
function GetItems(Index: Integer): TClass;
procedure SetItems(Index: Integer; AClass: TClass);
public
function Add(aClass: TClass): Integer;
function Remove(aClass: TClass): Integer;
function IndexOf(aClass: TClass): Integer;
procedure Insert(Index: Integer; aClass: TClass);
property Items[Index: Integer]: TClass
read GetItems write SetItems; default;
end;
不同于前面两个类，这个类继承于TList的类只是将Add, Remove, IndexOf, Insert和Items 调用的参数从指针换成了TClass元类类型。
TOrderedList, TStack和TQueue 类
Contnrs单元还定义了其它三个类：TOrderedList, TStack和TQueue，类型定义如下：
TOrderedList = class(TObject)
*******
FList: TList;
protected
procedure PushItem(AItem: Pointer); virtual; abstract;
...
public
function Count: Integer;
function AtLeast(ACount: Integer): Boolean;
procedure Push(AItem: Pointer);
function Pop: Pointer;
function Peek: Pointer;
end;
TStack = class(TOrderedList)
protected
procedure PushItem(AItem: Pointer); override;
end;
TQueue = class(TOrderedList)
protected
procedure PushItem(AItem: Pointer); override;
end;
要注意虽然TOrderedList 并不是从TList继承的，但是它在内部的实现时，使用了TList来储存指针。另外注意TOrderedList类的PushItem 过程是一个抽象过程，所以我们无法实例化 TOrderedList 类，而应该从TOrderedList继承新的类，并实现抽象的PushItem方法。TStack 和 TQueue 正是实现了PushItem抽象方法的类， 我们可以实例化TStack 和TQueue类作为后进先出的堆栈 (LIFO)和先进先出的队列(FIFO)。下面是这两个的的方法使用说明：
· Count 返回列表中的项目数。
· AtLeast 可以用来检查链表的大小，判断当前列表中的指针数目是否大于传递的参数值，如果为True表示列表中的项目数大于传来的参数。
· 对于TStack类Push 方法将指针添加到链表的最后，对于TQueue类Push 方法则将指针插入到链表的开始。
· Pop返回链表的末端指针，并将其从链表中删除。
· Peek返回链表的末端指针，但是不将其从链表中删除。
TObjectStack和TObjectQueue类
Contnrs单元中最后两个类是TObjectStack和TObjectQueue类，类的定义如下：
TObjectStack = class(TStack)
public
procedure Push(AObject: TObject);
function Pop: TObject;
function Peek: TObject;
end;
TObjectQueue = class(TQueue)
public
procedure Push(AObject: TObject);
function Pop: TObject;
function Peek: TObject;
end;
TIntList 类
到目前为止，我们看到的容器类中保存的都是指针或者对象引用（对象引用其实也是一种指针）。
那么我们能不能在链表中保存原生类型，如Integer，Boolean或者Double等呢。下面的我们定义的类TIntList 类就可以在链表中保存整数，这里我们利用了整数和指针都占用４个字节的存储空间，所以我们可以直接将指针映射为整数。
unit IntList;
interface
uses
Classes;
type
TIntList = class(TList)
protected
function GetItem(Index: Integer): Integer;
procedure SetItem(Index: Integer;
const Value: Integer);
public
function Add(Item: Integer): Integer;
function Extract(Item: Integer): Integer;
function First: Integer;
function IndexOf(Item: Integer): Integer;
procedure Insert(Index, Item: Integer);
function Last: Integer;
function Remove(Item: Integer): Integer;
procedure Sort;
property Items[Index: Integer]: Integer
read GetItem write SetItem; default;
end;
implementation
{ TIntList }
function TIntList.Add(Item: Integer): Integer;
begin
Result := inherited Add(Pointer(Item));
end;
function TIntList.Extract(Item: Integer): Integer;
begin
Result := Integer(inherited Extract(Pointer(Item)));
end;
function TIntList.First: Integer;
begin
Result := Integer(inherited First);
end;
function TIntList.GetItem(Index: Integer): Integer;
begin
Result := Integer(inherited Items[Index]);
end;
function TIntList.IndexOf(Item: Integer): Integer;
begin
Result := inherited IndexOf(Pointer(Item));
end;
procedure TIntList.Insert(Index, Item: Integer);
begin
inherited Insert(Index, Pointer(Item));
end;
function TIntList.Last: Integer;
begin
Result := Integer(inherited Last);
end;
function TIntList.Remove(Item: Integer): Integer;
begin
Result := inherited Remove(Pointer(Item));
end;
procedure TIntList.SetItem(Index: Integer;
const Value: Integer);
begin
inherited Items[Index] := Pointer(Value);
end;
function IntListCompare(Item1, Item2: Pointer): Integer;
begin
if Integer(Item1) < Integer(Item2) then
Result := -1
else if Integer(Item1) > Integer(Item2) then
Result := 1
else
Result := 0;
end;
procedure TIntList.Sort;
begin
inherited Sort(IntListCompare);
end;
end.
扩展TList，限制类型的对象列表
Begin Listing Two - TMyObjectList
TMyObject = class(TObject)
public
procedure DoSomething;
end;
TMyObjectList = class(TObjectList)
protected
function GetItems(Index: Integer): TMyObject;
procedure SetItems(Index: Integer; AMyObject: TMyObject);
public
function Add(aMyObject: TMyObject): Integer;
procedure DoSomething;
function Remove(aMyObject: TMyObject): Integer;
function IndexOf(aMyObject: TMyObject): Integer;
procedure Insert(Index: Integer; aMyObject: TMyObject);
property Items[Index: Integer]: TMyObject
read GetItems write SetItems; default;
end;
...
{ TMyObjectList }
function TMyObjectList.Add(AMyObject: TMyObject): Integer;
begin
Result := inherited Add(AMyObject);
end;
procedure TMyObjectList.DoSomething;
var
i: Integer;
begin
for i := 0 to Count-1 do
Items[i].DoSomething;
end;
function TMyObjectList.GetItems(Index: Integer): TMyObject;
begin
Result := TMyObject(inherited Items[Index]);
end;
function TMyObjectList.IndexOf(AMyObject: TMyObject):
Integer;
begin
Result := inherited IndexOf(AMyObject);
end;
procedure TMyObjectList.Insert(Index: Integer;
AMyObject: TMyObject);
begin
inherited Insert(Index, AMyObject);
end;
function TMyObjectList.Remove(AMyObject: TMyObject):
Integer;
begin
Result := inherited Remove(AMyObject);
end;
procedure TMyObjectList.SetItems(Index: Integer;
AMyObject: TMyObject);
begin
inherited Items[Index] := AMyObject;
end;
End Listing Two