Page Comparison

This section of the document covers the syntax, keywords, operators, etc in the Groovy language.

...

Data types in Groovy

Groovy offers a wide variety of built-in data types. Following is a list of data types which are defined in Groovy

Booleans

true and false are the only two primitive boolean values.

Define a boolean object:

boolean isActive = true
isActive = false

Groovy has special rules to coerce non-boolean objects to a boolean value, referred as Truthy and Falsy. Groovy decides an expression as Truthy when;

• If a boolean value is true
• Non-empty Collections and arrays are true
• True if the Matcher has at least one match
• Iterators and Enumerations with further elements are coerced to true
• Non-empty Maps are evaluated to true
• Non-empty Strings, GStrings and CharSequences are coerced to true
• Non-zero numbers are true
• Non-null object references are coerced to true

Any other value is considered Falsy. Eg: An empty string.

Collections

This section lists some of the collections in Groovy. See here for detailed information.

Lists

Groovy uses a comma-separated list of values, surrounded by square brackets, to denote lists. Groovy lists are plain JDK java.util.List, as Groovy doesn’t define its own collection classes.

Initialising a list:

You can initialise a list delimiting the values by commas and surrounded by square brackets. You can also create lists containing values of heterogeneous types:

def numbers = [1, 2, 3] 
def hetero = [1, "a", true]

Accessing a list:

• You can access the first element of the list on zero-based counting: hetero[0]
• You can access the last element of the list with a negative index: hetero[-1]

Set

A collection that contains no duplicate elements. Set has its implementation in various classes like HashSet, TreeSet, LinkedHashSet. All these permit null values too.

HashSet:

A HashSet class is used to create a collection that uses a hash table for storage. It inherits the AbstractSet class and implements Set interface. HashSet stores the elements by using a mechanism called hashing. HashSet contains unique elements only.

LinkedHashSet:

LinkedHashSet class is a Hash table and Linked list implementation of the set interface. It inherits HashSet class and implements Set interface. 

Initialising a Set/HashSet:

def HashSet names = [] //Initialising a HashSet

set.add("Oliver")
set.add("Casper")
set.add("elvis")
set.add("Elvis")
set.add("John")
set.add("Carter")
set.add("Oliver")
	
names == [Oliver, Elvis, John, Casper, elvis, Carter]

Maps

Groovy features maps. Maps associate keys to values, separating keys and values with colons, and each key/value pairs with commas, and the whole keys and values surrounded by square brackets.

Initialising a Map:

You need pass quoted strings if your key string isn’t a valid identifier Eg: "block-no". You must surround the variable or expression with parentheses, when you need to pass variable values as keys in your map definitions. Eg:

def colors = [red: "#FF0000", green:"#00FF00", blue: "#0000FF"] 
def doctor = [name: "Oliver","block-no":33,speciality:"Cardiology"]
place = [(address):"Oliver"]

Accessing the elements of a Map:

• Check the content associated with the red key: colors["red"]
• Add a pair to the Map: colors["pink"] = "#FF00FF" or colors.pink = "#FF00FF"
• Map contains a specific key: colors.blue == true

Arrays

Groovy reuses the list notation for arrays, but to make such literals arrays, you need to explicitly define the type of the array through coercion or type declaration. You can also create multi-dimensional arrays

Initialising an Array :

String[] arrStr = ["Apple", "Banana", "Kiwi"]  

def matrix3 = new Integer[3][3]  //Array with bounds
def matrix = new String[][]      //Array without bounds

Accessing the elements of an array:

...

This section of the document covers the syntax, keywords, operators, etc in the Groovy language.

1 + 2 == 3
3 / 2 == 1.5
10 % 3 == 1

def a = 5
b = a += 3
b == 8

def c = 4
def d = c++
d == 5

def c = 5
c *= 3
c == 15

a > b
b - 3 == a
b + 3 != a

x and y
x || y
!x

!true == false
!'' == true

def text = "Test"
if (text!=null && text.length()>0) {
    result = text
} else {
    result = 'Empty'
}

def text = "Test"
text ? text : 'Empty'

def text = "Test"
text ?: 'Empty'

if(employee){
  employee.getSalary()
}

employee?.getSalary()

//Simple if
if(..){
  (...)
}
//Simple if else
if(..){
  (...)
}
else{
  (...)
}
//Nested if
if (...) {
    ...
} else if (...) {
    ...
} else {
    ...
}

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
	default:
        result = "default"
}

// iterate over a range
def x = 0
for ( i in 0..9 ) {
    x += i
}
x == 45

// iterate over an array
def array = (0..4).toArray()
x = 0
for ( i in array ) {
    x += i
}
x == 10

...