创建序列的一种方法是显式列出其各个项。每个项都用一个逗号进行分隔，列表用方括号 "[" 和 "]" 括起来。例如，下面的代码：

def weekDays = ["Mon","Tue","Wed","Thu","Fri"];

声明了一个序列并将其赋给 weekDays。我们在这个例子中使用了 def， 因为在创建序列后我们不打算改变它的值。这里，编译器知道我们打算创建一个“字符串序列”，因为每个项都声明为 String 字面值。如果序列是使用 Integer 声明的（例如，def nums = [1,2,3];）， 编译器将知道我们打算创建“整数序列”。

您还可以显式指定序列的类型，方法是修改序列的声明，使其包含后跟 "[]" 的类型名称。

def weekDays: String[] = ["Mon","Tue","Wed","Thu","Fri"];

这会通知编译器 weekDays 将用来存放 String 序列（而不是单个 String）。

您还可以在序列中声明其他序列：

def days = [weekDays, ["Sat","Sun"]];

在这种情况下，编译器将自动平展开嵌套的序列以构成单个序列，这样上面的代码就等效于：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

还可以通过简化表示法来更方便地创建可构成等差数列的序列。要创建一个由数字 1 至 100 构成的序列，请使用以下代码：

def nums = [1..100];

您可以使用布尔表达式（又称为谓词）声明一个为现有序列的子集的新序列。例如，请考虑以下代码：

def nums = [1,2,3,4,5];

要创建第二个序列（基于此第一个序列中的项）但仅包含大于 2 的数字，请使用以下代码：

def numsGreaterThanTwo = nums[n | n > 2];

可以将上面的代码行用中文表示为：“从 nums 序列中选择项值大于 2 的所有项并将这些项赋给名为 numsGreaterThanTwo 的新序列。”以粗体突出显示的“项值大于 2”子句是谓词。

在这些代码中：

1. 新创建的序列存储在 numsGreaterThanTwo 中。
2. 代码 nums[n | n > 2]; 中标记为粗体的部分指定要从中复制项的原始序列。在我们的示例中，nums 是原始序列的名称。
3. 这会选择 nums 中的项，并按顺序返回一个由使表达式为 true 的项构成的新序列。
4. "|" 字符用来在视觉上将变量 "n" 与代码的其余部分隔开：nums[n | n > 2];
5. 代码 nums[n | n > 2]; 中标记为粗体的部分定义一个布尔表达式，该表达式指定将当前项复制到新序列中时需要满足的条件。

序列中的项是按数字索引（从 0 开始）进行访问的。要访问单个项，请键入序列名称，后跟该项的数字索引（用方括号括起来）：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            

            println(days[0]);

            println(days[1]);

            println(days[2]);

            println(days[3]);

            println(days[4]);

            println(days[5]);

            println(days[6]);

这会将以下内容输出到屏幕上：

Mon

            Tue

            Wed

            Thu

            Fri

            Sat

            Sun

您还可以使用后跟序列名称的 sizeof 运算符来确定序列的大小：

sizeof days

以下代码会将 "7" 输出到屏幕上：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            println(sizeof days);

insert 关键字可用于在序列中特定项的前面或后面插 入一个项。

---

注：从技术上讲,序列是不可变的，即一经创建就永不更改。在修改序列（例如通过插入或删除项）时，会在后台创 建一个新序列并重新指定序列变量，这会给人一种序列已被修改的印象。

---

让我们通过重新创建 days 序列来对此进行研究。请注意，我们现在用 var 来声明变量 days，因为我们会在创建原始序列后改变它的值：

var days = ["Mon"];

此时，该序列仅包含一个项 "Mon"。

我们可以使用 insert 和 into 关键字在该序列的末尾插入 "Tue"：

insert "Tue" into days;

类似地，我们也可以添加 "Fri"、"Sat" 和 "Sun"：

insert "Fri" into days;

            insert "Sat" into days;

            insert "Sun" into days;

该序列中现在包含："Mon"、"Tue"、"Fri"、"Sat" 和 "Sun"。

我们还可以使用 insert 和 before 关键字在给定索引处的项前面插入一个项。请记住，索引是从 0 开始的，因此，在当前的序列中，"Fri" 位于索引位置 2。因此，我们可以在 "Fri" 前面插入 "Thu"，如下所示：

insert "Thu" before days[2];

该序列中现在包含："Mon"、"Tue"、"Thu"、"Fri"、"Sat" 和 "Sun"。

要在 "Tue" 后面插入 "Wed"，我们可以使用 insert 和 after 关键字：

insert "Wed" after days[1];

该序列现在包含一周中的每一天："Mon"、"Tue"、"Wed"、"Thu"、"Fri"、"Sat" 和 "Sun"。

通过使用 delete 和 from 关键字可以轻松地从序列中删除项：

delete "Sun" from days;

该序列中现在包含："Mon"、"Tue"、"Wed"、"Thu"、"Fri" 和 "Sat"。

还可以删除位于特定索引位置的项。以下代码从该序列中删除 "Mon"（请记住，"Mon" 是第一个项，因此它的索引位置为 0）。

delete days[0];

要删除序列中的所有项，请使用后跟序列名称的 delete 关键字：

delete days;

请注意，delete 仅从序列中删除项，而不从脚本中删除 days 变量。您仍可以像以前那样访问 days 变量并向其中添加新项。

使用 reverse 运算符可以轻松地颠倒序列中项的次序：

var nums = [1..5];

            reverse nums; // returns [5, 4, 3, 2, 1]

有时，您可能希望对序列进行比较，看它们是否相等。序列是按值来比较是否相等的：如果它们的长度相同而且各个项相等，则它 们相等。

让我们创建两个具有相同内容的序列来对此进行测试：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,2,3,4,5];

            println(seq1 == seq2);

表达式 seq1 == seq2 的值为 true，因为这两 个序列具有相同数量的项，而且这两个序列中每个项的值都相等。因此，这些代码会将 "true" 输出到屏幕上。

通过更改其中一个序列中项的数量（而不更改另一个序列），这两个序列现在具有不同的长度：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,2,3,4,5,6];

            println(seq1 == seq2);

由于第二个序列比第一个序列长，从而这两个序列不相等，因此该脚本的输出为 "false"。

我们还可以通过更改项的值来使两个序列不相等（即使这两个序列的长度仍相同）：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,3,2,4,5];

            println(seq1 == seq2);

由于这两个序列不相等，因此这些代码将再次输出 "false"。

序列子集提供对序列某些部分的访问。

seq[a..b]

此语法提供对位于索引 a 和索引 b之间（含 a 和 b）各个项的访问。以下脚本创建一个 weekend 序列，其中仅包含 "Sat" 和 "Sun" 项。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            def weekend = days[5..6];

seq[a..<b]

使用 "<" 字符可以访问位于索引 a 和索引 b 之间（含 a，不含 b）的项。我们可以对 days 使用此方法来创建一个 weekdays 序列，其中包含项 "Mon" 至 "Fri"。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            def weekdays = days[0..<5];

seq[a..]

通过省略第二个索引，可以访问从索引 a 到序列末尾处的所有项。为了与上一个示例保持一致，我们可以按如下方式创建 weekend 序列：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            def weekend = days[5..];

seq[a..<]

最后，您可以使用不带第二个索引的 "<" 来访问从索引 a 到序列末尾处的所有项（不 含最后一项）。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            def days2 = days[0..<];

此版本会创建一个 days2 序列，其中包含项 "Mon" 至 "Sat"。