Java Programming Tutorials

Java programming tutorials with many code examples!

Groovy for Java Developers

Groovy for Java Developers – essentials

In this tutorial you will learn the most common features of Groovy that will allow you to get up and running in just a few minutes!

Basic syntax

Basically you can start with writing Java code inside Groovy, but here are some things that can simplify your code and life.

Optional semicolons

Semicolons ; are totally optional and very rarely used, so instead of this Java version:

package com.farenda.tutorials;

import java.time.Clock;

methodCall();

You can write:

package com.farenda.tutorials

import java.time.Clock

methodCall()

Optional “.class”

The same is with “.class” static, which is very often used in tests:

println(String.class.name)
println(String.name)

Prints the same:

java.lang.String
java.lang.String

Casting types

The as keyword is used to cast types in Groovy:

def numbers = [1, 2, 3]
println("Type: ${numbers.class.name}")

def casted = numbers as Set
println("Type: ${casted.class.name}")

Gives the following results:

Type: java.util.ArrayList
Type: java.util.LinkedHashSet

Default imports

By default Groovy imports the following packages and classes:

  • java.lang
  • java.util
  • java.io
  • java.net
  • groovy.lang
  • groovy.util
  • java.math.BigInteger
  • java.math.BigDecimal

Aliases in imports

When you need to import two classes that have the same name you can create an alias to prevent conflicts. Or it can be used to shorten name of some very long class name (sometimes generated classes have such names). Example:

// aliases with shorter names:
import javax.xml.parsers.DocumentBuilder as DocBuilder
import javax.xml.parsers.DocumentBuilderFactory as DocFactory

// ... then in code:
def factory = DocFactory.newInstance()
DocBuilder db = factory.newDocumentBuilder()

Strings

Groovy has three kinds of strings:

// Simple string are within apostrophes '':
def simpleString = 'String'
println('Like in Java: ' + simpleString)

// GString are within quotes "":
println("GStrings can access vars: ${simpleString.toUpperCase()}")

// Multiline are within triple ':
def longString = '''Multiline
    line
string'''
println(longString)

Note that the indentation in multiline string is preserved!

The above code produces the following text:

Like in Java: String
GStrings can access vars: STRING
Multiline
    line
string

Groovy Collections

Very nice feature of Groovy is a bunch of literals for creating lists, sets, and maps – especially useful in tests.

Groovy Lists

def numbers = [1, 2, 3]
println(numbers)
println("first: ${numbers.first()}")
println("at 0: ${numbers[0]}")
println("at 1: ${numbers[1]}")
println("1st and 2nd: ${numbers[0, 1]}")
println("from 1st to 3nd: ${numbers[0..2]}")

The above code produces the following:

first: 1
at 0: 1
at 1: 2
1st and 2nd: [1, 2]
from 1st to 3nd: [1, 2, 3]

Adding and removing to a list:

numbers.add(4)
println(numbers)

numbers += 5
println(numbers)

numbers += [6, 7]
println(numbers)

numbers << 8 << 9
println(numbers)

// remove range of numbers:
numbers -= (4..8)
println(numbers)

Results:

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 9]

Groovy Sets

Sets can be created in very similar way to lists:

// range of numbers as set:
Set numbers = (1..10)
println("type: ${numbers.class.name}")
println("set content: ${numbers}")

def letters = ['a', 'b', 'c'] as Set
println("type: ${letters.class.name}")
println("set content: ${letters}")

Gives:

type: java.util.LinkedHashSet
set content: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
type: java.util.LinkedHashSet
set content: [a, b, c]

Groovy Maps

def player = 'baz'
// [string, quotes may be omitted, name from var]:
def points = ['foo': 1, bar: 2, (player): 3]
println(points)

points.put('baz', 33)
println(points)

points['foo'] = 11
println("foo has ${points.foo} ponits")

Note that when map key is a string quotes can be omitted! So to use a variable (here player) as a map key we have to surround it with brackets.

The above code produces:

[foo:1, bar:2, baz:3]
[foo:1, bar:2, baz:33]
foo has 11 ponits

Useful functions

def words = ['Some', 'random', 'string', 'for', 'processing']

// 'it' is default name of processed element:
def sizes = words.collectEntries {[(it.toLowerCase()): it.size()]}
println("sizes: ${sizes}")

def shorts = words
        .findAll { it.size() <= 4 }
        .collect { word -> word.toLowerCase() }
        .sort()
println('short words: ' + shorts)

println('has proc? ' + words.any { it.contains('proc')})
println('how many? ' + words.count { it.contains('proc')})

The output is:

sizes: [some:4, random:6, string:6, for:3, processing:10]
short words: [for, some]
has proc? true
how many? 1

It’s just the beginning

Groovy has many, many more features than presented in this introductory tutorial, but at least it should help you to start right away! :-)

If you would like to learn more about Groovy language I recommend you to read Groovy in Action 2nd Edition. It is a great book covering Groovy language in depth!

References:

Share with the World!