- Home
- Groovy
- Basic programming snippets in Groovy
Before going to start with snippets, just wanted to tell you that Grrovy is scripting language for Java, Can make more dynamic. Comparing with Java, more similarities even in coding side also. will try to cover some areas in Groovy.
If we know Java and Javascript can easily understand Groovy.
Variable creation
Here no need to specify type for variable like javascript
def x = false
def y = 5
if - else statement
Groovy supports the usual if - else syntax from Java.
def x = false
def y = false
if ( !x ) {
x = true
}
assert x == true
if ( x ) {
x = false
} else {
y = true
}
assert x == y
Groovy also supports the normal Java "nested" if then else if syntax
Ternary operator
Groovy also supports the ternary operator:
def y = 5
def x = (y > 1) ? "worked" : "failed"
assert x == "worked"
Switch statement
The switch statement in Groovy is backwards compatible with Java code; so you can fall through cases sharing the same code for multiple matches.
One difference though is that the Groovy switch statement can handle any kind of switch value and different kinds of matching can be performed.
def x = 1.23
def result = ""
switch ( x ) {
case "foo":
result = "found foo"
// lets fall through
case "bar":
result += "bar"
case [4, 5, 6, 'inList']:
result = "list"
break
case 12..30:
result = "range"
break
case Integer:
result = "integer"
break
case Number:
result = "number"
break
default:
result = "default"
}
assert result == "number"
Looping
Groovy supports the usual while {...} and for loops like Java.
def x = 0
def y = 5
while ( y-- > 0 ) {
x++
}
assert x == 5
// iterate over a range
def x = 0
for ( i in 0..9 ) {
x += i
}
assert x == 45
// iterate over a list
x = 0
for ( i in [0, 1, 2, 3, 4] ) {
x += i
}
assert x == 10
// iterate over an array
array = (0..4).toArray()
x = 0
for ( i in array ) {
x += i
}
assert x == 10
// iterate over a map
def map = ['abc':1, 'def':2, 'xyz':3]
x = 0
for ( e in map ) {
x += e.value
}
assert x == 6
// iterate over values in a map
x = 0
for ( v in map.values() ) {
x += v
}
assert x == 6
// iterate over the characters in a string
def text = "abc"
def list = []
for (c in text) {
list.add(c)
}
assert list == ["a", "b", "c"]
Closures
In addition, you can use closures in place of most for loops, using each() and eachWithIndex():
def stringList = [ "java", "perl", "python", "ruby", "c#", "cobol",
"groovy", "jython", "smalltalk", "prolog", "m", "yacc" ];
def stringMap = [ "Su" : "Sunday", "Mo" : "Monday", "Tu" : "Tuesday",
"We" : "Wednesday", "Th" : "Thursday", "Fr" : "Friday",
"Sa" : "Saturday" ];
stringList.each() { print " ${it}" }; println "";
stringMap.each() { key, value -> println "${key} == ${value}" };
// Su == Sunday
// We == Wednesday
// Mo == Monday
// Sa == Saturday
// Th == Thursday
// Tu == Tuesday
// Fr == Friday
stringList.eachWithIndex() { obj, i -> println " ${i}: ${obj}" };
try-catch blocks
For try/catch/finally blocks, the last expression evaluated is the one being returned. If an exception is thrown in the try block, the last expression in the catch block is returned instead. Note that finally blocks don't return any value.
def method(bool) {
try {
if (bool) throw new Exception("foo")
1
} catch(e) {
2
} finally {
3
}
}
assert method(false) == 1
assert method(true) == 2
Operator Overloading
Groovy supports operator overloading which makes working with Numbers, Collections, Maps and various other data structures easier to use.
Various operators in Groovy are mapped onto regular Java method calls on objects.
This allows you the developer to provide your own Java or Groovy objects which can take advantage of operator overloading. The following table describes the operators supported in Groovy and the methods they map to.
Operator |
Method |
a + b |
a.plus(b) |
a - b |
a.minus(b) |
a * b |
a.multiply(b) |
a ** b |
a.power(b) |
a / b |
a.div(b) |
a % b |
a.mod(b) |
a | b |
a.or(b) |
a & b |
a.and(b) |
a ^ b |
a.xor(b) |
a++ or ++a |
a.next() |
a-- or --a |
a.previous() |
a[b] |
a.getAt(b) |
a[b] = c |
a.putAt(b, c) |
a << b |
a.leftShift(b) |
a >> b |
a.rightShift(b) |
switch(a) { case(b) : } |
b.isCase(a) |
~a |
a.bitwiseNegate() |
-a |
a.negative() |
+a |
a.positive() |
Note that all the following comparison operators handle nulls gracefully avoiding the throwing of java.lang.NullPointerException.
Operator |
Method |
a == b |
a.equals(b) or a.compareTo(b) == 0 ** |
a != b |
! a.equals(b) |
a <=> b |
a.compareTo(b) |
a > b |
a.compareTo(b) > 0 |
a >= b |
a.compareTo(b) >= 0 |
a < b |
a.compareTo(b) < 0 |
a <= b |
a.compareTo(b) <= 0 |