Groovy(四)-布尔值，Lists，Arrays，Maps

译文:Groovy Language Documentation

布尔值
布尔值是一种用来表示真值：true和false的特殊数据类型。用这种数据类型可以设置简单的标志位来跟踪true／false情况。

布尔类型可以保存在变量中，赋值给属性，跟其他数据类型一样：

def myBooleanVariable = true
boolean untypedBooleanVar = false
booleanField = true

true和false是仅有的两种原始boolean值，更加复杂的布尔表达式可以用逻辑运算符来表达。

另外，groovy有一些特殊的规则（通常对于Groovy中的真值）来使非boolean对象转化为boolean对象。

Lists
Groovy使用点来分隔一串数值，并且用中括号括起来来表示list集合。Groovy的list集合是java的jdkjava.util.List,因为groovy没有提供自己的集合类。具体的list实现是在定义list常量的时候，默认是java.util.ArrayList，除非你想自己指定另外的类型，我们接下来就会看到。

def numbers = [1, 2, 3]         1

assert numbers instanceof List  2
assert numbers.size() == 3      3

1.我们用逗号来划分一组数字，并且用中括号来包括，最后赋值给常量。
2.这个集合是java中java.util.List接口的实例。
3.集合的大小可以用方法size（）来询问。最终回返回这个集合有三个元素。

在上面的例子中，我们的集合元素都是同类型的。但是你能创建一个包含不同类型元素的集合。

def heterogeneous = [1, "a", true]   1

1.集合中包含一个数字类型，一个字符类型，一个布尔类型的元素。

前面我们提到过，我们的集合默认是java.util.ArrayList实例，但是也可以使用as操作符来强制使它转化为另外一种集合类型。或者明确指明一种类型。

def arrayList = [1, 2, 3]
assert arrayList instanceof java.util.ArrayList

def linkedList = [2, 3, 4] as LinkedList                1
assert linkedList instanceof java.util.LinkedList

LinkedList otherLinked = [3, 4, 5]                      2
assert otherLinked instance java.util.LinkedList

1.我们可以使用as操作符来明确指明实现java.util.LinkedList.
2.我们能说这个变量里面保存着java.util.LinkedList类型的集合常量。

你可以用[]操作符然后里面带上正数或者负数来访问集合中(用来取值或者设置值)的元素，其中正数或者负数是表示从集合的头开始还是尾部开始算，或者代表一个集合范围。而且可以使用<<来往集合中添加元素。

def letters = ['a', 'b', 'c', 'd']

assert letters[0] == 'a'     1
assert letters[1] == 'b'

assert letters[-1] == 'd'    2
assert letters[-2] == 'c'

letters[2] = 'C'             3
assert letters[2] == 'C'

letters << 'e'               4
assert letters[ 4] == 'e'
assert letters[-1] == 'e'

assert letters[1, 3] == ['b', 'd']         5
assert letters[2..4] == ['C', 'd', 'e']    6

1.访问集合中的第一个元素，集合是从零开始算的。
2.使用－1来访问集合的话代表是访问集合尾部开始算第一个元素。
3.使用赋值符来给集合中的第三个元素进行设值。
4.使用<<操作符来往集合的最后添加元素。
5.同时给集合中的两个位置设置新的值，返回一个带有这两个新值的集合。
6.使用一个范围来访问集合中的元素，表示从2开始，到4位置结束。

就像集合中可以包含多种类型的元素一样，集合中也可以包含另外的集合来创建一个多维的集合。

def multi = [[0, 1], [2, 3]]     1
assert multi[1][0] == 2          2

1.定义一个多维的数字集合。
2.访问第二个集合中的第一个元素。

数组
Groovy重用了集合中的表示方法来表示数组。但是对于数组类型的变量，你需要通过强制转化或者明确指明来确定数组类型。

String[] arrStr = ['Ananas', 'Banana', 'Kiwi']  1

assert arrStr instanceof String[]    2
assert !(arrStr instanceof List)

def numArr = [1, 2, 3] as int[]      3

assert numArr instanceof int[]       4
assert numArr.size() == 3

1.明确指明字符类型数组的类型。
2.断言说我们创建的事字符类型的数组。
3.使用as操作符来创建一个int类型的数组。
4.断言说我们创建了一个int基本类型的数组。

你也可以创建多维数组：

def matrix3 = new Integer[3][3]         1
assert matrix3.size() == 3

Integer[][] matrix2                     2
matrix2 = [[1, 2], [3, 4]]
assert matrix2 instanceof Integer[][]

1.你能定义一个新数组的大小。
2.或者你可以创建一个没有明确大小的数组。

使用以下标记来访问集合中的元素：

String[] names = ['Cédric', 'Guillaume', 'Jochen', 'Paul']
assert names[0] == 'Cédric'     1

names[2] = 'Blackdrag'          2
assert names[2] == 'Blackdrag'

1.取出数组中的第一个元素。
2.设置数组中的第三个元素为新元素。

注意: Groovy不支持java中数组初始化的方法，因为java中的{}跟Groovy中的闭包会混淆。

Maps
通常在其他语言中我们叫字典或者关联数组，但是在groovy中我们称作map，map是键值对关联，键和值之间用:隔开，而且每个键值对之间用逗号隔开，整个map用中括号[]包含。

def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']   
 1
assert colors['red'] == '#FF0000'    2
assert colors.green  == '#00FF00'    3

colors['pink'] = '#FF00FF'           4
colors.yellow  = '#FFFF00'           5

assert colors.pink == '#FF00FF'
assert colors['yellow'] == '#FFFF00'

assert colors instance java.util.LinkedHashMap

1.我们定义了一个以颜色名称为key，以十六进制颜色值为value的map集合。
2.我们使用下标索引的方式来看key为red对应的value值。
3.我们使用属性索引的方式来看green对应的十六进制值。
4.同样，我们可以通过下标索引的方式来添加一个键值对。
5.或者属性索引的方式来添加一个yellow的颜色。

注意：当我们用名称来当作key，要确保map中有这个名称对应的key。Groovy中创建的map集合实际上是java.util.LinkedHashMap的实例。

如果你访问了一个不存在的key：

assert colors.unknown == null

你将得到一个null值。

在上面的例子中我们都是使用字符作为key，其实我们也可以使用其他类型来作为key。

def numbers = [1: 'one', 2: 'two']

assert numbers[1] == 'one'

这里，我们将数字作为键，因为数字可以明确被识别为数字，所以在前面的例子中groovy不会创建一个字符类型的key。但是想象一种场景，你会传一个变量来代替key，这个变量所代表的值变成了key。

def key = 'name'
def person = [key: 'Guillaume']      1

assert !person.containsKey('name')   2
assert person.containsKey('key')     3

1.key对应的'Guillaume'的键就是key这个字符串，而不是key变量所代表的name字符串。
2.这个map没有包含name这个key。
3.这个map包含了key这个键。

注意：你可以通过省略引号的字符串或者像这样["name": "Guillaume"]，但是如果你的key不是合法的标识符时，你必须添加上引号，像这里一样["street-name": "Main street"].

当你想要传一个变量或者表达式作为key时，你必须添加上()：

person = [(key): 'Guillaume']        1

assert person.containsKey('name')    2
assert !person.containsKey('key')    3

1.我们使用()括号来包含一个变量。说明我们不是为了声明一个key字符的键，而是传一个key的变量作为键。
2.这个map包含了name的键。
3.这个map没有包含key字符作为键。