1、集合

（1）List (java.util.List)

list = [1, 2, 'hello', new java.util.Date()]
assert list.size() == 4assert list.get(2) == 'hello'注意：一切都是對象（數字會自動轉換）

（2）Map (java.util.Map)

map = ['name':'James', 'location':'London']
assert map.size() == 2assert map.get('name') == 'James'（3）遍歷集合

list = [1, 2, 3]for (i in list) { println i }

2、  閉包（Closures）

l 閉包類似Java的內類，區別是閉包只有單一的方法可以調用，但可以有任意的參數

closure = { param | println("hello ${param}") }
closure.call("world!")
closure = { greeting, name | println(greeting + name) }
closure.call("hello ", "world!")
閉包用“{}”括起，“|”前面是參數，后面是處理語句，使用call調用

第一個例子演示了在字符串內使用參數的形式：${param}

第二個例子演示了多參數形式：用“，”分隔參數

如果只有一個參數，可以不寫，而使用缺省的參數“it”，如下面的例子：
closure = { println "hello " + it }closure.call("world!")

3、 each

遍歷集合，逐個傳遞給閉包

[1, 2, 3].each { item | print "${item}-" }l         上面例子的輸出結果是：1-2-3-
4、 collect

遍歷集合，逐個傳遞給閉包，處理后的結果返回給對應的項

value = [1, 2, 3].collect { it * 2 }assert value == [2, 4, 6]

5、 find

根據閉包斷言，返回集合中找到的第一個項目

value = [1, 2, 3].find { it > 1 }assert value == 2

6、 findAll

根據閉包斷言，返回集合中所有找到的項目

value = [1, 2, 3].findAll { it > 1 }assert value == [2, 3]

7、 inject

l  遍歷集合，第一次將傳遞的值和集合項目傳給閉包，將處理結果作為傳遞的值，和下一個集合項目傳給閉包，依此類推

value = [1, 2, 3].inject('counting: ')
 { str, item | str + item }
assert value == "counting: 123"
 value = [1, 2, 3].inject(0) { count, item | count + item }
assert value == 6

8、 every

如果集合中所有項目都匹配閉包斷言，就返回true，否則返回false

value = [1, 2, 3].every { it < 5 }
assert value value = [1, 2, 3].every { item | item < 3 }
assert ! value

9、 any

如果集合中任何項目匹配閉包斷言，就返回true，否則返回false

value = [1, 2, 3].any { it > 2 }
assert value value = [1, 2, 3].any { item | item > 3 }
assert value == false

10、min/max

l  返回集合中的最小/最大項目（對象必須可比較）

value = [9, 4, 2, 10, 5].max()
assert value == 10value = [9, 4, 2, 10, 5].min()
assert value == 2value = ['x', 'y', 'a', 'z'].min()
assert value == 'a'

11、join

連接集合中的值成一個字符串

value = [1, 2, 3].join('-')assert value == '1-2-3'

12、 yield

在Python和Ruby中通過yield語句創建“yield”風格的iterators，在Groovy同樣有效，只是使用的是閉包

class Foo{       
static void main(args) {           
  foo = new Foo()            
 for (x in foo.myGenerator) {        
       print("${x}-")        
     }    
  }      
 myGenerator(Closure yield) {            
 yield.call("A")          
   yield.call("B")         
    yield.call("C")   
   }}

 例子的輸出結果是：A-B-C-

 Cloures原型可以省略，call和括號同樣可選，這樣更象Python/Ruby

class Foo {     
 myGenerator(yield) {    
         yield "A"    
         yield "B"      
       yield "C"    
   }  
     static void main(args) {     
        foo = new Foo()    
         foo.myGenerator { println "Called with ${it}" } 
     }
}