groovy-集合

Lists

你能使用下面的方法建立一个lists，注意[]是一个空list。

1	def list = [5, 6, 7, 8]

2	assert list.get(2) == 7

3	assert list[2] == 7

4	assert list instanceof java.util.List

5

6	def emptyList = []

7	assert emptyList.size() == 0

8	emptyList.add(5)

9	assert emptyList.size() == 1

每一个列表表达式都是建立了 java.util.List的一个实例。

Ranges

Ranges允许你建立一个值序列，这个只序列能够被用做Lists，由于Range继承自Java.util.List.

Ranges 使用 ..来定义，而且包含两端的值

Ranges 也可使用 ..< 来定义半开闭序列，这样建立的序列将包含最左边的，可是不包含最右边的：

1	// an inclusive range

2	def range = 5..8

3	assert range.size() == 4

4	assert range.get(2) == 7

5	assert range[2] == 7

6	assert range instanceof java.util.List

7	assert range.contains(5)

8	assert range.contains(8)

9

10	// lets use a half-open range

11	range = 5..<8

12	assert range.size() == 3

13	assert range.get(2) == 7

14	assert range[2] == 7

15	assert range instanceof java.util.List

16	assert range.contains(5)

17	assert ! range.contains(8)

18

19	//get the end points of the range without using indexes

20	def range = 1..10

21	assert range.from == 1

22	assert range.to == 10

Ranges适用于任何的实现了 java.lang.Comparable接口的Java对象，并且他也有next()和 previous() 方法来访问下一个和上一个元素。

好比你能够在Ranges中是用String：

1	// an inclusive range

2	def range = 'a'..'d'

3	assert range.size() == 4

4	assert range.get(2) == 'c'

5	assert range[2] == 'c'

6	assert range instanceof java.util.List

7	assert range.contains('a')

8	assert range.contains('d')

9	assert ! range.contains('e')

Ranges能够和for循环结合起来讲使用：

1	for (i in 1..10) {

2	println "Hello ${i}"

3

}

使用下面的代码也能够达到上述的效果：

1	(1..10).each { i ->

2	println "Hello ${i}"

3

}

Ranges固然也能够用在switch中：

1	switch (years) {

2	case 1..10: interestRate = 0.076; break;

3	case 11..25: interestRate = 0.052; break;

4	default: interestRate = 0.037;

5

}

Maps

注意 [:] 实际上是一个空的Map。

Map的key若是是string的话，默认是这种形式: [a:1]，它等价于["a":1]. 可是若是你真的想让一个变量做为key的话，那么你必须使用括号将他包起来： [(a):1].

1	def map = [name:"Gromit", likes:"cheese", id:1234]

2	assert map.get("name") == "Gromit"

3	assert map.get("id") == 1234

4	assert map["name"] == "Gromit"

5	assert map['id'] == 1234

6	assert map instanceof java.util.Map

7

8	def emptyMap = [:]

9	assert emptyMap.size() == 0

10	emptyMap.put("foo", 5)

11	assert emptyMap.size() == 1

12	assert emptyMap.get("foo") == 5

Maps也有点想beans，这样就可使用.号来获取属性：

1	def map = [name:"Gromit", likes:"cheese", id:1234]

2	assert map.name == "Gromit"

3	assert map.id == 1234

4

5	def emptyMap = [:]

6	assert emptyMap.size() == 0

7	emptyMap.foo = 5

8	assert emptyMap.size() == 1

9	assert emptyMap.foo == 5

更有效的使用’*.’操做符

咱们可使用这个操做符来操做集合中的全部元素：

1	assert [1, 3, 5] == ['a', 'few', 'words']*.size()

加强的集合方法：

好比下面的例子：

1	def words = ['ant', 'buffalo', 'cat', 'dinosaur']

2	assert words.findAll{ w -> w.size() > 4 } == ['buffalo', 'dinosaur']

下面的这个例子获取了全部元素的首字母：

1	def words = ['ant', 'buffalo', 'cat', 'dinosaur']

2	assert words.collect{ it[0] } == ['a', 'b', 'c', 'd']

切片操做符

1	def text = "nice cheese gromit!"

2	def x = text[2]

3

4	assert x == "c"

5	assert x.class == String

6

7	def sub = text[5..10]

8	assert sub == 'cheese'

9

10	def map = [name:"Gromit", likes:"cheese", id:1234]

11

12	assert map["name"] == "Gromit"

13	assert map.name == "Gromit"

14

15	def list = [10, 11, 12]

16	def answer = list[2]

17	assert answer == 12

下面再给出一些例子：

1	def list = 100..200

2	def sub = list[1, 3, 20..25, 33]

3	assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]

也可使用切片操做符来更新元素

1	def list = ["a", "b", "c"]

2	list[2] = "d"

3	list[0] = list[1]

4	list[3] = 5

5	assert list == ["b", "b", "d", 5]

咱们可使用负数来从尾部获取 List, array, String 等的值：

1	def text = "nice cheese gromit!"

2	def x = text[-1]

3	assert x == "!"

4

5	def name = text[-7..-2]

6	assert name == "gromit"

若是你使用一个向后的索引，也就是说前面的值比后面的大，好比[3:1]，那么获得的结果是相反的:

1	def text = "nice cheese gromit!"

2	def name = text[3..1]

3	assert name == "eci"

Dynamic objects (Expandos)

Expando 在严格意义上来讲并非一个集合。可是有点相似于Map, .他允许你充分理由Groovy’s closure mechanisms来建立动态对象， 可是 Expando和Map不一样的是他能够提供 synthetic methods 。

1	def player = new Expando()

2	player.name = "Dierk"

3	player.greeting = { "Hello, my name is $name" }

4

5	println player.greeting()

6	player.name = "Jochen"

7	println player.greeting()

The player.greeting assignment passes in a closure to execute when greeting() is called on the Expando. Notice that the closure has access to the properties assigned to the Expando, even though these values may change over time, using Groovy’s GString ”$variableOrProperty” notation.