打开窗口设计器，分别拖放“按钮”和“编辑框”，给按钮起名“按钮1”。
编辑框的“组件宽度类型”和“组件高度类型”分别设置为“匹配父组件宽度”和“匹配内容高度”。
最后点击“确定”，右键“按钮”，添加“按钮_被单击”接收事件方法。
添加完毕后，顺便利用“如果”指定“来源对象==按钮1”。
作者：创世魂
● 帮助说明
本篇教程中针对各种数据进行处理。
包含“哈希表”，“列表”，“枚举器”，“数组”等各种数据处理。
具体看本教程右侧树型列表。
● 准备工作
界面如下图：
打开窗口设计器，分别拖放“按钮”和“编辑框”，给按钮起名“按钮1”。
编辑框的“组件宽度类型”和“组件高度类型”分别设置为“匹配父组件宽度”和“匹配内容高度”。
最后点击“确定”，右键“按钮”，添加“按钮_被单击”接收事件方法。
添加完毕后，顺便利用“如果”指定“来源对象==按钮1”。
● 本类说明
1、在本教程中有“两个子类”继承自本类，共用本类中的所有方法。
2、注意“所有模板类”不支持直接调用，需要通过“子类”才能调用模板类中的方法。
3、本模板类，总共有“三个模板类型”，可看图内的模板类型的简单说明。
哈希表基本概念：哈希表（也叫散列表），是根据“关键码值”而直接进行访问的数据结构。
也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做“散列函数”，存放记录的数组叫做“哈希表”。
● 文本到对象哈希表类
帮助文档如下图：
1、本类继承自“哈希表模板类”，那么本类也就是“哈希表模板类”的子类。
2、通过本类，可以去调用“哈希表模板类”也就是“父类”的所有方法。
3、通过“所设置值”可以看到，本类有“文本型，对象类”和“文本到对象哈希表项数据集类”三个数据类型。
4、这三个数据类型分别对应“哈希表模板类”中的三个模板类型。
也就是说：“模板类型1”实际的数据类型为“文本型”，凡是在本类中遇到“模板类型1”的就表示是“文本型”数据。
“模板类型2”对应“对象类”。
“模板类型3”对应“文本到对象哈希表项数据集类”。
● 文本到文本哈希表类
本类同样也是继承自“哈希表模板类”，可使用“哈希表模板类”的所有方法。
不同之处是“模板类型”对应的的实际数据类型不同。
在本类中“模板类型1和2”都表示“文本型”，“模板类型3”表示“文本到文本哈希表项数据集类”。
以下开始讲解“哈希表模板类”中的各个方法如何使用。
以上类除了“模板类型”代表的数据类型不同之外，其它用法基本一致。
此处以“文本到文本哈希表类”举例。
● 创建
● 置入
● 读取
以上为三个为关联方法，这里统一讲解。
“创建”帮助文档：
执行本方法后，会创建一个当前对象，对象的“容量”跟参数内设定的“容量”有关系。
如果填写“10”，那么本对象中只能容纳“10个”成员。
"置入"帮助文档：
本方法的作用就是给创建好的“哈希表模板类”，设置成员数值。
成员有两个部分组成，分别是“关键字”和“要设置的值对象”，有点类似于程序配置项。
注意：如果“关键字”已经存在，则会覆盖原来的“值对象”，并且还会将原来的值返回。
"读取"帮助文档：
本方法的作用就是通过“关键字”读取设置的“值”，并且将值返回。
代码编写如下图：
1、定义两个变量，类型分别为“文本到文本哈希表类”和“文本型”，前者注意要设置参考。
2、随后利用“创建”方法，创建对象后赋值给定义的“哈希表”变量。
3、通过本类中关于“模板类型”的描述可以得知，此处的“模板类型1、2”均是文本型数据（其它方法不再讲解）。
3、在调用“置入”方法时，参数直接填写文本即可。
4、然后赋值给“前一个值”变量。
注意：此处的“前一个值”只有在“关键字”存在的时候，本变量才有返回值，否则返回的是空对象。
5、因在此之前没有进行过任何“置入”操作，所以此处的“前一个值”变量，必然为空对象。
6、最后可以调用“读取”方法，读取“关键字”显示在“编辑框1”中。
运行效果如下图（gif）：
点击“按钮1”后，成功将“设置的值”取出。
● 值是否存在
帮助文档如下图：
顾名思义，就是判断当前类中，是否已经存储了指定值。
返回“真”为存在，返回“假”为不存在。
代码编写如下图：
依然需要创建当前“哈希表”对象，然后利用“哈希表”变量去调用“值是否存在”方法。
在本代码的演示中，必然会返回“假”，提示“不存在”。
因为并没有“置入”要检查的值。
运行效果图：
结果也确实是如此，点击“按钮1”后提示“不存在”。
● 关键字是否存在
帮助文档如下图：
本方法的作用就是用来检查当前对象的“关键字”是否存在。
代码编写参考上一个方法，此处不再演示。
● 取成员数
帮助文档如下图：
顾名思义就是取出当前对象的“成员数”。
代码编写如下图：
依然是创建当前“哈希表”对象，成员数填写“10”。
然后调用“置入”方法置入一个成员后，最后调用“取成员数”方法读取成员数。
运行结果如下图：
可以看到最终的结果显示“1”，也就证明“创建”时填写的成员数，并不是最终的“成员数量”了。
决定成员数量跟“置入”方法有关系。
● 取数据集
帮助文档如下图：
顾名思义，本方法的作用会取出当前对象的“数据集”对象。
通过上面关于本类的模板类型描述可以得知，“模板类型3”实际数据类型为“文本到文本哈希表项数据集类”。
除此之外还有一个方法可以判断，点击“模板类型3”可以查看具体的类型。
可以看到“文本到文本哈希表类”的“实际类型”为“文本到文本哈希表项数据集类”。
代码编写如下图：
1、创建当前对象，然后随便置入两个成员。
2、除此之外还需要定义一个类型为“文本到文本哈希表项数据集类”的变量，要设置参考。
3、随后通过“哈希表”调用“取数据集”方法，赋值给定义的“哈希表项”变量。
4、最后可以通过“哈希表项”调用“取成员数”方法获取成员数量。
运行效果：
执行“按钮1”编辑框内显示“成员数2”。
证明通过本方法可以读取“哈希表”内的成员数量。
● 复制
帮助文档如下图：
顾名思义，就是复制当前对象，并且返回创建一个新的对象。
新的对象，拥有当前对象的所有数据。
代码编写如下图：
1、通过“哈希表”变量调用“复制”方法后。
2、“新哈希表”必然拥有“哈希表”所有的成员数据。
运行结果如下图：
“按钮1”被点击后，通过新哈希表读取数据成功。
● 是否为空
帮助文档如下图：
顾名思义，本方法就是用来判断当前对象“是否为空”。
代码编写如下图：
直接通过“哈希表”变量调用本方法，最后判断本方法的返回值即可。
运行结果如下图：
不进行任何数据置入的情况下，本方法必然返回真。
● 删除
帮助文档如下图：
顾名思义，就是删除指定“关键字”。
如果“关键字”存在会将“当前值”返回，否则返回空对象。
代码编写如下图：
1、创建当前“哈希表”对象，随便“置入”两个成员。
2、调用“删除”方法，删除“关键字1”，赋值给“返回值3”变量。
3、最后将“返回值3”和“成员数”都显示在编辑框中。
运行效果如下图：
成功取出被删除的关键字的值，除此之外成员数也减少了。
● 清除
帮助文档如下图：
顾名思义，调用本方法后会“清除”当前“哈希表”的所有内容。
代码编写如下图：
1、创建当前对象后，置入一个成员，并取出成员数。
2、调用“清除”方法后再次取出成员数。
运行结果如下图：
清除后成员数将为0。
二、哈希表项模板类
● 本类说明
1、本模板类有两个“模板类型”和“三个方法”。
2、本类同样也不能直接调用，需要通过“子类”来调用本类中的方法。
3、在本教程中介绍“两个子类”，分别为“文本到对象哈希表项类”和“文本到文本哈希表项类”。
● 文本到对象哈希表项类
帮助文档如下图：
本方法继承自“哈希表项模板类”，可以使用它的所有方法。
它的所设置值是“文本型”和“对象类”，分别对应“模板类型1和2”。
● 文本到文本哈希表项类
帮助文档如下图：
本类同样也继承自“哈希表项模板类”，不同之处是，它的所设置值是两个“文本型”。
也就表示在本类中“模板类型1、2”都表示“文本型”。
以上两个类除了“模板类型”代表的实际类型不同之外，基本用法一致。
此处讲解“文本到文本哈希表项类”。
● 设置值
● 取值
“设置值”帮助文档：
顾名思义，设置表项中“关键字”对应的值数据。
“模板类型2”实际类型为“文本型”，所以代码编写时直接填写文本值即可。
“取值”帮助文档：
本方法的作用就是取出值，并返回。
代码编写如下图：
1、代码略微复杂，需要定义五个变量。
2、类型分别为“文本到文本哈希表类”，“文本到文本哈希表项类”，“文本到文本哈希表项数据集类”、“文本到文本哈希表项枚举器类”和“文本型”。
3、定义完毕后，前四个需要设置参考。
4、首先需要创建“哈希表”对象，通过“哈希表”的“置入”方法添加一个“关键字”成员。
5、通过“哈希表”调用“取数据集”赋值给“哈希集”变量。
6、然后通过本变量调用“创建枚举器”赋值给“表项枚举器”变量。
7、随后需要通过“枚举器”变量，调用“是否有下一成员”方法，判断是否有成员存在。
此方法的作用是防止某些情况下，成员为空的时候报错。
8、然后调用“到下一成员”方法赋值给“哈希表项”，这样我们就获得了“哈希表项”对象。
9、通过“哈希表项”变量调用“设置值”，就可以为当前成员设置一个文本值。
10、最后调用“取值”方法，就可以将设置的值取出。
运行效果如下图：
点击“按钮1”后，编辑框内就会显示设置的文本值。
● 取关键字
帮助文档如下图：
本方法的作用就是读取出来“置入”方法填写的关键字名称。
代码编写如下图：
直接在上一个方法的代码上简单修改即可。
运行结果如下图：
最终结果会在编辑框内显示“置入”方法置入的关键字名称。
三、集合模板类
● 本类说明
在本类中，共有两个“模板类型”。
本教程介绍了“六个类”继承自本类，共用本类中的所有方法。
本类同样不能直接调用，需要通过“子类”去调用。
● 文本到对象哈希表项集合类
帮助文档如下图：
本类继承自“集合模板类”，可使用此类中所有方法。
通过“所设置值”可以看出，“模板类型1、2”的实际数据类型为“文本到对象哈希表项类”和“文本到对象哈希表项枚举器类”。
● 文本到对象哈希表项数据集类
帮助文档如下图：
同样继承自“集合模板类”，继承了本类中所有的用法。
通过“所设置值”可以看出，“模板类型1、2”的实际数据类型为“文本到对象哈希表项类”和“文本到对象哈希表项集合类”。
本类可通过“文本到对象哈希表类”中的“取数据集”方法创建本对象。
● 文本到文本哈希表项集合类
帮助文档如下图：
同样继承自“集合模板类”，不同之处在于。
通过“所设置值”可以看出，“模板类型1、2”的实际数据类型为“文本到文本哈希表项类”和“文本到文本哈希表项枚举器类”。
● 文本到文本哈希表项数据集类
帮助文档如下图：
本类的不同之处在于，“模板类型1、2”的实际数据类型为“文本到文本哈希表项类”和“文本到文本哈希表项集合类”。
本类用法可参考“文本到文本哈希表项类”。
● 文本数据集类
帮助文档如下图：
本类的不同之处在于，“模板类型1、2”的实际数据类型为“文本型”和“文本集合类”。
本类的操作可以参考安卓文件操作实例中的“置文本集配置项”方法。
● 文本集合类
帮助文档如下图：
本类的不同之处在于，“模板类型1、2”的实际数据类型为“文本型”和“文本枚举器类”。
以上“六个类”除了模板类型的实际数据类型不同之外，方法的调用基本一致。
此处举例“文本集合类”。
● 添加成员
● 取成员数
“添加成员”帮助文档：
顾名思义，给当前类添加一个成员，在本类中“模板类型1”实际类型为“文本型”。
代码编写时，直接写文本即可。
添加成功返回真，否则返回假。
“取成员数”帮助文档：
顾名思义，就是取出当前类的成员数量。
返回值为一个“整数型”。
代码编写如下图：
1、“按钮1”被单击，定义两个变量设置参考，一个类型为“文本集合类”，另外一个类型为“文本枚举器类”。
2、利用“文本哈希集类.创建()”方法，可以创建当前对象。
3、调用“添加成员”方法，随便添加两个成员。
4、调用“取成员数”方法，取出成员数量放到编辑框中。
5、如果想要把所有的成员列举出来，需要利用“创建枚举器”方法。
6、创建的枚举器赋值给“枚举器”变量。
7、使用“循环”命令，将所有成员循环出来。
8、其中“到下一成员”方法，可以将成员取出。
运行结果如下图：
点击“按钮1”后编辑框内就会出现如下信息。
成员数显示2，也就证明“创建”方法创建的数量，不代表真正的成员数。
● 添加成员2
帮助文档如下图：
本方法的作用就是将指定“集合模板类”中的所有成员，添加到“本模板类”中。
注意：只要有一个成员添加进去，就会“返回真”。
代码编写如下图：
只需要在上一个方法的代码中简单修改即可。
1、定义两个“文本集合类”，分别创建它们，并且给分别添加成员。
2、通过“集合类1”调用“添加成员2”方法，将“集合类2”写入参数中。
3、最后将“集合类1”的“所有成员”输入。
运行结果如下图：
可以看到成功输出了两个成员，并且成员数也变成了2.
● 是否为空
帮助文档如下图：
顾名思义，就是用来判断当前类是否有数据，如果没有任何数据返回“真”，否则返回“假”。
代码编写如下图：
直接用“如果”命令去判断当前方法返回值即可。
运行结果如下图：
如果在不设置任何内容的情况下，本方法必然返回真。
● 是否包含
● 是否包含2
以上两个方法都是用来判断“文本集合内”是否包含指定内容。
此处演示“是否包含”方法。
帮助文档如下图：
顾名思义，就是用来判断本对象中是否存在指定成员，如果存在返回“真”否则返回“假”。
在本类中，参数2的“模板类型1”的实际数据类型为“文本型”，直接填写要判断文本即可。
帮助文档如下图：
直接用“如果”判断当前方法的返回值即可。
帮助文档如下图：
当判断一个不存在集合中的成员时，本方法必然返回假。
● 到数组
帮助文档如下图：
1、本方法的作用是将当前对象，转换成数组，在本类中数组类型为“文本型”。
2、“参数2”的缓冲数组对象的作用。
3、如果“缓冲数组”的成员数“大于等于”本集合类类的成员数，则优先转入“缓冲数组”内，否则转换的数组会返回。
例如：本集合类中有“五个成员”，而“缓冲数组”有超过五个成员，则放到转换后的数组放入缓冲数组内。
假如说，缓冲数组成员只有“两个”，那么数组将会返回。
代码编写如下图：
1、创建两个“文本型数组”，其中一个设置成员数“1”。
2、创建集合类后随便添加两个成员，然后使用“到数组”方法，将数组变量写入参数，并且赋值给一个数组变量。
3、这样的情况下，最终的结果会赋值给“文本数组”，而缓冲文本数组内，并不会有任何数据。
4、最后调用“循环”命令，将数组数据输出。
运行结果如下图：
点击“按钮1”可以看到两个成员成功输出，不过输出的顺序和添加时是相反的。
● 删除指定成员
帮助文档如下图：
本方法顾名思义，就是删除指定成员，删除成功返回“真”，否则返回“假”。
在本类中，参数2直接填写要删除的文本成员即可。
代码编写如下图：
1、创建“集合类”后，随便添加三个成员。
2、然后调用“删除指定成员”方法，删除“222”。
3、最后“创建枚举器”让所有成员输出到编辑框。
运行结果如下图：
点击“按钮1”可以看到，只输出了两个成员，“222”被删除。
● 删除指定成员2
帮助文档如下图：
本方法的作用就是将“集合1”中所有“集合2”的成员全部删除。
只要成功删除“一个”，则返回“真”。
代码编写如下图：
1、定义“集合类1”并循环添加10个成员。
2、定义“集合类2”并循环添加3个成员。
2、利用“集合类1”调用当前方法删除“集合类2”所拥有的所有成员。
4、最后取出“集合类1”的成员数量，用来验证删除结果。
运行结果如下图：
最终结果得到“集合类1”的成员数为7，证明集合类1删除成员成功。
● 删除指定成员3
帮助文档如下图：
本方法的作用就是，删除“集合1”中所有“集合2”不存在的成员。
例如：“集合1”有成员“1、2、3”，“集合2”有成员“3、4、5”。
那么最终结果会将“集合1”中的“1、2”删除，因为它并不存在于“集合2”中。
代码编写如下图：
1、创建“集合类1”变量并添加三个成员。
2、创建“集合类2”变量并添加两个成员，其中一个成员在“集合类1”中存在。
3、调用当前方法删除“集合类2”中不存在的成员。
4、将删除后的“集合类1”转换为数组显示在编辑框中。
运行结果如下图：
最终结果，集合类1中的成员只会剩下“3”。
● 删除所有成员
帮助文档如下图：
本方法的作用会将当前类中所有的成员删除，也就是进行了清空操作。
代码编写如下图：
1、定义“集合类1”变量，并添加一些成员。
2、调用当前方法清除所有成员。
3、取出成员数显示在编辑框中。
运行结果如下图：
最终“集合类1”中成员数为0，证明成员被全部删除。
四、枚举器模板类
● 本类说明
帮助如下图：
本类不能直接调用方法，需要通过“子类”来进行调用。
本类中共有三个方法和一个模板类型。
在本教程中介绍三个类，分别为：“文本到对象哈希表项枚举器类”，“文本到文本哈希表项枚举器类”和“文本枚举器类”。
● 文本到对象哈希表项枚举器类
帮助文档如下图：
通过“所设置值”可以得出，本类中的“模板类型1”的实际数据类型为“文本到对象哈希表项类”。
本类继承了“枚举器模板类”的所有方法。
本类可参考“文本到文本哈希表项类”的用法。
● 文本到文本哈希表项枚举器类
帮助文档如下图：
通过“所设置值”可以得出，本类中的“模板类型1”的实际数据类型为“文本到文本哈希表项类”。
本类继承了“枚举器模板类”的所有方法。
本类可参考“文本到文本哈希表项类”的用法。
● 文本枚举器类
帮助文档如下图：
通过“所设置值”可以得出，本类中的“模板类型1”的实际数据类型为“文本型”。
本类同样继承了“枚举器模板类”的所有方法。
本类可参考“文本集合类”的用法。
● 是否有下一成员
帮助文档如下图：
顾名思义，就是用来判断当前枚举器“是否存在下一个成员”。
本方法可参考“文本集合类”的用法。
● 到下一成员
帮助文档如下图：
顾名思义，本方法的作用就是返回下一个成员的数据。
如果没有下一个成员，则返回空对象。
假如，本方法是通过“文本枚举器”调用的，那么本方法中的“模板类型1”实际类型数据为“文本型”。
本方法可参考“文本集合类”的用法。
● 删除当前成员
帮助文档如下图：
当调用“到下一个成员”方法后，那么下一个成员就是“当前成员”。
如果此时调用当前方法，那么这个成员就会被删除。
成功删除返回“真”失败返回“假”。
代码编写如下图：
1、创建文本集合类对象并添加三个成员。
2、创建枚举器对象，并执行“到下一成员()”方法。
3、删除当前成员后取出当前集合类的成员数。
运行结果如下图：
最终结果证明，集合类中被成功删除了一个成员。
五、哈希集模板类
● 本类说明
帮助文档如下图：
本模板类同样不同直接调用方法，需要通过“子类”来调用。
可以看到本类共有“两个”模板类型和“六个”方法。
●文本哈希集类
帮助文档如下图：
可以看到，本类不仅继承自“哈希集模板类”同样也继承了“集合模板类”。
重点讲解“哈希集模板类”的方法。
通过“所设置值”可以知道，“模板类型1、2”的实际数据类型为“文本型”和“文本数据集类”。
●创建
●加入
●是否存在
“创建”帮助文档如下图：
本方法的作用就是创建一个“哈希集模板类”对象。
“文本哈希集类”是“哈希集模板类”的子类，所以可以通过本方法创建文本哈希集。
参数直接填写要创建的成员数即可。
“加入”帮助文档如下图：
给当前哈希集添加关键字对象，在本类中“模板类型1”的实际数据类型为“文本型”。
所以参数直接写文本数据即可。
成功加入返回真，失败返回假。
“是否存在”帮助文档如下图：
本方法顾名思义，就是判断指定关键字是否存在。
代码编写如下图：
1、首先创建两个变量，类型分别为“文本哈希集类”和“文本枚举器类”，并设置参考。
2、调用“创建”方法创建本类，赋值给“哈希集”变量。
3、调用“加入”方法加入一个关键字。
4、调用“是否存在”判断是否加入成功。
5、通过“枚举器”的“到下一成员”方法可以取出当前“关键字”。
运行结果如下图（GIF）：
可以看到点击“按钮1”后，弹出提示“存在”，并且编辑框内也显示了加入进去的“关键字”。
●复制
帮助文档如下图：
顾名思义，就是将当前对象复制一份并返回。
返回的对象，将会拥有当前对象所有的数据。
代码编写如下图：
1、创建“哈希集”对象，并添加关键字。
2、定义“哈希集2”变量，调用“哈希集.复制()”方法，赋值给此变量。
3、利用“是否存在()”方法，判断“哈希集2”是否存在数据。
运行结果如下图：
哈希集2存在数据，证明复制成功。
●删除
帮助文档如下图：
顾名思义，就是删除指定关键字。
删除成功返回真，失败返回假。
代码编写如下图：
创建当前对象后，“加入”三个关键字。
然后调用“删除”方法删除其中一个。
最后利用“枚举器”将所有成员枚举出来，显示在编辑框内。
运行结果如下图：
可以看到只有两个关键字显示出来。
●清除
帮助文档如下图：
顾名思义，就是删除所有关键字。
代码编写如下图：
1、创建“哈希集”对象后，并添加关键字。
2、调用“清除()”方法后，取出哈希集的成员数验证。
运行结果如下图：
最终结果证明，哈希集内所有成员被删除。
六、列表模板类
● 本类说明
帮助说明：
本模板类共有“3个模板类型”和“9个方法”。
本类同样不支持直接调用方法，需要通过子类调用本类中的方法。
● 文本列表类
帮助文档如下图：
可以看到本类不仅继承自“列表模板类”，同样也继承了“集合模板类”的方法。
通过“所设置值”看看出本类中“模板类型1、2、3”实际数据类型分别为“文本型”，“文本集合类”和“文本列表枚举器类”。
● 插入成员
● 取成员
“插入成员”帮助文档如下图：
本方法的作用就是在“指定索引位置”插入成员。
插入成功返回真，失败返回假，“失败原因”可看红框内的说明。
参数3在本类中的实际数据类型为“文本型”。
“取成员”帮助文档如下图：
顾名思义，取出“指定索引”项的成员。
如果指定索引不存在，程序会异常闪退。
代码编写如下图：
1、“文本列表类”的创建，需要通过去定义一个“文本数组类”变量。
2、然后将“数组类”赋值给“列表类”变量。
3、调用“插入成员”方法，进行成员的添加操作，第一次插入索引值填写“0”。
4、最后调用“取成员”方法，取出成员显示在“编辑框”中。
运行效果如下图：
点击“按钮1”后，插入的成员就会显示在“编辑框1”内。
● 插入成员2
帮助文档如下图：
本方法的不同之处在于，插入的成员是“文本集合类”。
本方法会将“集合类”中的所有成员插入到当前列表类中。
成功插入一个成员返回真，失败返回假。
失败原因可看红框内的提示。
代码编写如下图：
1、首先需要定义“文本集合类”变量，创建当前集合类，然后添加成员。
2、然后就是创建“列表类”的那一套代码，此处需要增加一个“文本枚举器类”变量。
3、调用“插入成员2”方法，插入“集合类”变量。
4、通过“列表类”创建枚举器，赋值给“枚举器”变量。
5、利用“循环”方法将“所有成员”枚举出来验证结果。
运行效果如下图：
程序运行后点击“按钮1”，就可以看到“集合类”的成员和“列表类”的成员全部被枚举了出来。
也就间接证明，“集合类”成功的插入到了“列表类”中。
● 替换成员
帮助文档如下图：
顾名思义，就是根据“参数2”指定的索引，替换成“参数3”的新成员。
替换成功返回真，失败返回假。
代码编写如下图：
1、创建列表类对象后，随便插入三个成员。
2、然后调用本方法，替换“索引1”的成员。
3、创建“枚举器”，利用“循环”方法将所有成员枚举出来。
运行效果如下图：
最后结果可以看到“222”已经被替换成指定的文本。
● 查找成员
帮助文档如下图：
本方法的作用就是从“列表类”中第一个成员开始“查找成员”。
返回“第一个”被找到的成员索引位置，如果未找到返回“-1”。
代码编写如下图：
例如：代码中我们插入两个“333”。
然后调用“查找成员”方法，去查找“333”。
运行结果如下图：
点击“按钮1”后，最终的结果会返回“位置1”。
● 倒找成员
帮助文档如下图：
本方法和“查找成员”的不同之处在于，本方法是从最后一个成员开始向前查找。
找到后返回成员索引位置，未找到“返回-1”。
本方法代码可参考“查找成员”，此处不再详细讲解。
● 删除指定位置成员
帮助文档如下图：
本方法的作用就是删除“指定索引”的成员。
参数2如果不填写，默认删除“索引0”。
成功删除“返回真”，失败原因可以看“红框”内的说明。
代码编写如下图：
1、插入成员后直接调用本方法，但是不填写参数。
2、创建“枚举器”，利用“循环”方法将所有成员输出到编辑框。
运行结果如下图：
最后可以看到，成员“111”并没有被输出，被成功删除。
● 删除指定范围成员
帮助文档如下图：
本方法和“删除指定位置成员”不同之处就是增加了一个“删除成员数目”参数。
它的作用就是删除这个范围内的所有成员。
成功删除“返回真”，失败“返回假”。
代码编写如下图：
1、创建“文本列表类”对象，并循环插入10个成员。
2、调用当前方法删除指定范围的成员。
3、转换成文本数组显示在编辑框中验证结果。
运行结果如下图：
最终结果证明指定范围的成员被删除成功。
● 创建列表枚举器
帮助文档如下图：
顾名思义，就是创建一个“列表枚举器”。
通过枚举器类可以将列表内的所有成员枚举出来。
本方法不再详细介绍，可以看下面的教程“文本列表枚举器类”中的操作。
注意：“列表枚举器类”中的方法是从“列表尾部”向前枚举。
“参数2”中的“索引位置”，通常情况下填写当前列表的“成员数”。
七、列表枚举器模板类
● 本类说明
帮助文档如下图：
本模板类同样也需要通过“子类”来调用方法。
本类中共有“两个”模板类型和“六个”方法。
● 文本列表枚举器类
帮助文档如下图：
本方法是“列表枚举器模板类”子类，并且同样也继承了“枚举器模板类”的所有方法。
通过“所设置值”可以看出，本类中“模板类型1、2”的实际数据类型为“文本型”和“文本枚举器类”。
本类重点讲解“列表枚举器模板类”方法的使用。
● 是否有上一成员
● 到上一成员
“是否有上一成员”帮助文档如下图：
本方法的作用就是用来判断，是否存在上一个成员。
存在返回“真”，不存在返回“假”。
“到上一成员”帮助文档如下图：
本方法的作用就是将“上一个成员”取出并返回。
如果上一个成员不存在，则返回“空对象”。
代码编写如下图：
1、创建列表类后插入成员。
2、调用“创建列表枚举器”赋值给“列表枚举器”变量，参数内填写“列表类”的成员数。
3、然后调用“循环”方法，将所有的成员取出，显示在编辑框内。
运行结果如下图：
可以看到所有的成员全部取出，不过成员顺序并不是添加时的顺序。
● 插入成员
帮助文档如下图：
顾名思义，本方法的作用就是通过“枚举器”来插入成员。
插入成功返回真，失败返回假。
注意：如果插入失败，很有可能是当前对象不支持插入成员操作。
代码编写如下图：
1、在创建“列表枚举器”时，参数内填写“1”。
2、插入成员的时候，就会插入到“索引1”这个位置。
3、原来的索引“1、2”会依次自动后移一位。
4、将“索引1”通过“列表类.取成员”方法取出。
运行结果如下图：
最后可以看到，取出的成员是我们在代码中插入的成员。
● 取上一成员索引值
● 取下一成员索引值
代码编写如下图：
以上两个方法就是字面上的意思，取出“上下成员索引”。
不过要注意的是，此处的“取下一成员”并不真的代表是下一个成员索引，实际上取出的是当前索引。
例如：下方代码中“创建列表枚举器”填写的索引值是“2”。
“取上一索引值”就会取出“1”，而“取下一索引值”时会取当前索引值“2”。
运行效果如下图：
最终结果也证明了这一点，下一索引其实是当前索引值。
● 替换当前成员
帮助文档如下图：
顾名思义，就是就“当前索引”处的成员进行“替换”。
成功替换返回“真”，失败返回“假”。
本方法有三个注意事项，可看“红框”内的详细说明。
代码编写如下图：
1、想要调用本方法，必须要调用“到上一成员”或者“到下一成员”方法。
2、创建“枚举器”后，首先调用“到上一成员”，随后在调用本方法。
3、最终结果就会替换“索引1”处的内容，可以利用“取成员”方法验证结果。
运行结果如下图：
最终结果显示的正是被替换的文本。
八、数组列表模板类
● 本类说明
帮助文档如下图：
可以看到本模板类共有“两个模板类型”和“两个方法”。
同样需要通过“子类”去调用这些方法。
● 文本数组类
帮助文档如下图：
可以看到在本类中“模板类型1、2”的实际数据类型为“文本型”和“文本列表类”。
本数组类，除了继承自“数组列表模板类”之外。
同样还继承了“列表模板类”，“集合模板类”和“可枚举模板类”。
这些类中的方法都可以调用。
此处重点讲解“数组列表模板类”中方法的使用。
● 删除多余容量
帮助文档如下图：
通过“数组列表模板类”添加成员时，程序“申请内存”是会默认多申请一些。
例如：添加了“1000个”成员，理论上申请“1000字节”的内存足矣，但是程序默认会“多申请200”。
调用此命令后，会将多申请的200清理掉。
通常是在进行“大批量”的“成员添加”时使用，用来弥补内存不足的缺陷。
代码编写如下图：
定义“文本数组类”变量，名称随意。
注意：此处“不需要”设置参考。
然后通过“数组类”直接调用“添加成员”方法就可以进行成员添加操作。
继续调用本方法就可以清理多余的内存申请。
● 确保最小容量
帮助文档如下图：
本方法的作用就是提前“指定好成员数目”，防止在“添加成员”时频繁的“申请内存”。
代码编写如下图：
例如：你总共要添加“100”个成员，那就提前指定好容量为“100”。
这样程序就不会频繁的去申请内存。
