Your First Groovy

//hello.groovyprintln "hello, world"
for (arg in this.args ) {
  println "Argument:" + arg;
}
// this is a comment
/* a block comment, commenting out an alternative to above:
this.args.each{ arg -> println "hello, ${arg}"}
*/

To run it from command line

groovy hello.groovy MyName yourName HisName

Overview

Groovy classes compile down to Java bytecode and so there`s a 1-1 mapping between a Groovy class and a Java class.

Indeed each Groovy class can be used inside normal Java code - since it is a Java class too.

Probably the easiest way to get groovy is to try working with collections. In Groovy List (java.util.List) and Map (java.util.Map) are both first class objects in the syntax. So to create a List of objects you can do the following...

def list = [1, 2, `hello`, new java.util.Date()]
assert list.size() == 4
assert list.get(2) == `hello`
assert list[2] == `hello`

Notice that everything is an object (or that auto-boxing takes place when working with numbers). To create maps...

def map = [`name`:`James`, `location`:`London`]
assert map.size() == 2
assert map.get(`name`) == `James`
assert map[`name`] == `James`

Iterating over collections is easy...

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

Once you have some collections you can then use some of the new collection helper methods or try working with closures...

Working with closures

Closures are similar to Java`s inner classes, except they are a single method which is invokable, with arbitrary parameters. A closure can have as many parameters as you wish...

def closure = { param -> println("hello ${param}") }
closure.call("world!")
closure = { greeting, name -> println(greeting + name) }
closure.call("hello ", "world!")

If no parameter(s) is(are) specified before -> symbol then a default named parameter, called `it` can be used. e.g.

def closure = { println "hello " + it }
closure.call("world!")

Using closures allows us to process collections (arrays, maps, strings, files, SQL connections and so forth) in a clean way. e.g

[1, 2, 3].each ({ item -> print "${item}-" })
["k1":"v1", "k2":"v2"].each {key, value -> println key + "=" + value}

Note: If a given closure is the last parameter of a method, its definition can reside outside of the parentheses. Thus the following code is valid:

def fun(int i, Closure c) {
  c.call(i)
}
// put Closure out of ()
[1, 2, 3].each() { item -> print "${item}-" } // 1-2-3-
fun(123) { i -> println i } // 123
// omit ()

[1, 2, 3].each { item -> print "${item}-" }

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

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

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

def 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

def value = [1, 2, 3].every { it < 5 }
assert valuevalue = [1, 2, 3].every { item -> item < 3 }
assert ! value

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

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

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