1.GPath 支持

由于对列表和映射的属性表示法的支持，Groovy 提供了语法糖，使得处理嵌套集合变得非常容易，如下面的示例所示：

  1. def listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22]]
  2. assert listOfMaps.a == [11, 21] // GPath符号
  3. assert listOfMaps*.a == [11, 21] // 扩展点表示法
  5. listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22], null]
  6. assert listOfMaps*.a == [11, 21, null] // 空entry
  7. assert listOfMaps*.a == listOfMaps.collect { it?.a } // 等效符号
  8. // 但这只会收集非空值
  9. assert listOfMaps.a == [11,21]

2.扩展运算符

扩展运算符可用于将一个集合“内联”到另一个集合中。它是语法糖，通常避免调用putAll并促进单行代码的实现：

  1. assert [
  2.     'z': 900,
  3.     *: ['a': 100, 'b': 200],
  4.     'a': 300,
  5. ] == [
  6.     'a': 300,
  7.     'b': 200,
  8.     'z': 900,
  9. ]
  10. // Map中的扩展地图符号
  11. assert [
  12.     *: [
  13.         3: 3,
  14.         *: [5: 5],
  15.     ],
  16.     7: 7,
  17. ] == [
  18.     3: 3,
  19.     5: 5,
  20.     7: 7,
  21. ]
  23. def f = { [1: 'u', 2: 'v', 3: 'w'] }
  24. assert [
  25.     *: f(),
  26.     10: 'zz',
  27. ] == [
  28.     1: 'u',
  29.     10: 'zz',
  30.     2: 'v',
  31.     3: 'w',
  32. ]
  34. // 函数参数中的扩展映射表示法
  35. f = { map -> map.c }
  36. assert f(*: ['a': 10, 'b': 20, 'c': 30], 'e': 50) == 30
  38. f = { m, i, j, k -> [m, i, j, k] }
  39. //将扩展映射表示法与未命名和命名参数混合使用
  40. assert f('e': 100, *[4, 5], *: ['a': 10, 'b': 20, 'c': 30], 6) ==
  41.         [["e": 100, "b": 20, "c": 30, "a": 10], 4, 5, 6]

3.*.操作符

“星点”运算符是一种快捷运算符，允许您在集合的所有元素上调用方法或属性：

  1. assert [1, 3, 5] == ['a', 'few', 'words']*.size()
  3. class Person {
  4.     String name
  5.     int age
  6. }
  7. def persons = [new Person(name:'Hugo', age:17), new Person(name:'Sandra',age:19)]
  8. assert [17, 19] == persons*.age

4.下标运算符切片

您可以使用下标表达式对列表、数组、地图进行索引。有趣的是，在这种情况下，字符串被视为特殊类型的集合：

  1. def text = 'nice cheese gromit!'
  2. def x = text[2]
  4. assert x == 'c'
  5. assert x.class == String
  7. def sub = text[5..10]
  8. assert sub == 'cheese'
  10. def list = [10, 11, 12, 13]
  11. def answer = list[2,3]
  12. assert answer == [12,13]

请注意，您可以使用范围来提取集合的一部分：

  1. list = 100..200
  2. sub = list[1, 3, 20..25, 33]
  3. assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]

下标运算符可用于更新现有集合（对于不可变的集合类型）：

  1. list = ['a','x','x','d']
  2. list[1..2] = ['b','c']
  3. assert list == ['a','b','c','d']

值得注意的是，允许负索引，以便更容易地从集合的末尾提取：

  1. text = "nice cheese gromit!"
  2. x = text[-1]
  3. assert x == "!"

您可以使用负索引从列表、数组、字符串等的末尾开始计数。

  1. def name = text[-7..-2]
  2. assert name == "gromit"

最终，如果您使用向后的范围（起始索引大于结束索引），那么答案就会相反。

  1. text = "nice cheese gromit!"
  2. name = text[3..1]
  3. assert name == "eci"