// a standalone single line commentprintln "hello" // a comment till the end of the line

/* a standalone multiline comment   spanning two lines */println "hello" /* a multiline comment starting                   at the end of a statement */println 1 /* one */ + 2 /* two */

/** * A Class description */class Person {    /** the name of the person */    String name    /**     * Creates a greeting method for a certain person.     *     * @param otherPerson the person to greet     * @return a greeting message     */    String greet(String otherPerson) {       "Hello ${otherPerson}"    }}

/**@ * Some class groovydoc for Foo */class Foo {    /**@     * Some method groovydoc for bar     */    void bar() {    }}assert Foo.class.groovydoc.content.contains('Some class groovydoc for Foo')(1)assert Foo.class.getMethod('bar', new Class[0]).groovydoc.content.contains('Some method groovydoc for bar')(2)

#!/usr/bin/env groovyprintln "Hello from the shebang line"

A trick allows methods to be defined having the same name as a keywordby surrounding the name in quotes as shown in the following example:

Using such names might be confusing and is often best to avoid.The trick is primarily intended to enable certain Java integration scenariosand certainDSL scenarios wherehaving "verbs" and "nouns" with the same name as keywords may be desirable.

This extra lenience allows using method or variable names that were not keywords in earlierversions of Groovy or are not keywords in Java. Examples are shown here:

Groovy programmers familiar with these contextual keywords may still wish to avoidusing those names unless there is a good reason to use such a name.

While not recommended, the same trick as for reserved keywords can be used:

Using such words as method names is potentially confusing and is often best to avoid, however,it might be useful for certain kinds ofDSLs.

def namedef item3def with_underscoredef $dollarStart

def 3tierdef a+bdef a#b

foo.asfoo.assertfoo.breakfoo.casefoo.catch

def map = [:]map."an identifier with a space and double quotes" = "ALLOWED"map.'with-dash-signs-and-single-quotes' = "ALLOWED"assert map."an identifier with a space and double quotes" == "ALLOWED"assert map.'with-dash-signs-and-single-quotes' == "ALLOWED"

map.'single quote'map."double quote"map.'''triple single quote'''map."""triple double quote"""map./slashy string/map.$/dollar slashy string/$

def firstname = "Homer"map."Simpson-${firstname}" = "Homer Simpson"assert map.'Simpson-Homer' == "Homer Simpson"

'a single-quoted string'

assert 'ab' == 'a' + 'b'

'''a triple-single-quoted string'''

def aMultilineString = '''line oneline twoline three'''

def startingAndEndingWithANewline = '''line oneline twoline three'''

def strippedFirstNewline = '''\line oneline twoline three'''assert !strippedFirstNewline.startsWith('\n')

You can escape single quotes with the backslash character to avoid terminating the string literal:

And you can escape the escape character itself with a double backslash:

Some special characters also use the backslash as escape character:

We’ll see some more escaping details when it comes to other types of strings discussed later.

For characters that are not present on your keyboard, you can use unicode escape sequences:a backslash, followed by 'u', then 4 hexadecimal digits.

For example, the Euro currency symbol can be represented with:

"a double-quoted string"

Any Groovy expression can be interpolated in all string literals, apart from single and triple-single-quoted strings.Interpolation is the act of replacing a placeholder in the string with its value upon evaluation of the string.The placeholder expressions are surrounded by${}. The curly braces may be omitted for unambiguous dotted expressions,i.e. we can use just a $ prefix in those cases.If the GString is ever passed to a method taking a String, the expression value inside the placeholderis evaluated to its string representation (by callingtoString() on that expression) and the resultingString is passed to the method.

Here, we have a string with a placeholder referencing a local variable:

Any Groovy expression is valid, as we can see in this example with an arithmetic expression:

In addition to${} placeholders, we can also use a lone$ sign prefixing a dotted expression:

But only dotted expressions of the forma.b,a.b.c, etc, are valid. Expressions containing parentheses like method calls,curly braces for closures, dots which aren’t part of a property expression or arithmetic operators would be invalid.Given the following variable definition of a number:

The following statement will throw agroovy.lang.MissingPropertyException because Groovy believes you’re trying to access thetoString property of that number, which doesn’t exist:

Similarly, if the expression is ambiguous, you need to keep the curly braces:

If you need to escape the$ or${} placeholders in a GString so they appear as is without interpolation,you just need to use a\ backslash character to escape the dollar sign:

So far, we’ve seen we could interpolate arbitrary expressions inside the${} placeholder, but there is a special case and notation for closure expressions. When the placeholder contains an arrow,${→}, the expression is actually a closure expression — you can think of it as a closure with a dollar prepended in front of it:

In appearance, it looks like a more verbose way of defining expressions to be interpolated,but closures have an interesting advantage over mere expressions: lazy evaluation.

Let’s consider the following sample:

When a method (whether implemented in Java or Groovy) expects ajava.lang.String,but we pass agroovy.lang.GString instance,thetoString() method of the GString is automatically and transparently called.

Although interpolated strings can be used in lieu of plain Java strings,they differ with strings in a particular way: their hashCodes are different.Plain Java strings are immutable, whereas the resulting String representation of a GString can vary,depending on its interpolated values.Even for the same resulting string, GStrings and Strings don’t have the same hashCode.

GString and Strings having different hashCode values, using GString as Map keys should be avoided,especially if we try to retrieve an associated value with a String instead of a GString.

def name = 'Groovy'def template = """    Dear Mr ${name},    You're the winner of the lottery!    Yours sincerly,    Dave"""assert template.toString().contains('Groovy')

def fooPattern = /.*foo.*/assert fooPattern == '.*foo.*'

def escapeSlash = /The character \/ is a forward slash/assert escapeSlash == 'The character / is a forward slash'

def multilineSlashy = /one    two    three/assert multilineSlashy.contains('\n')

def color = 'blue'def interpolatedSlashy = /a ${color} car/assert interpolatedSlashy == 'a blue car'

An empty slashy string cannot be represented with a double forward slash, as it’s understood by the Groovy parser as a line comment.That’s why the following assert would actually not compile as it would look like a non-terminated statement:

As slashy strings were mostly designed to make regexp easier so a few things thatare errors in GStrings like$() or$5 will work with slashy strings.

Remember that escaping backslashes is not required. An alternative way of thinking of this isthat in fact escaping is not supported. The slashy string/\t/ won’t contain a tab but insteada backslash followed by the character 't'. Escaping is only allowed for the slash character, i.e./\/folder/will be a slashy string containing'/folder'. A consequence of slash escaping is that a slashy stringcan’t end with a backslash. Otherwise that will escape the slashy string terminator.You can instead use a special trick,/ends with slash ${'\'}/. But best just avoid using a slashy string in such a case.

def name = "Guillaume"def date = "April, 1st"def dollarSlashy = $/    Hello $name,    today we're ${date}.    $ dollar sign    $$ escaped dollar sign    \ backslash    / forward slash    $/ escaped forward slash    $$$/ escaped opening dollar slashy    $/$$ escaped closing dollar slashy/$assert [    'Guillaume',    'April, 1st',    '$ dollar sign',    '$ escaped dollar sign',    '\\ backslash',    '/ forward slash',    '/ escaped forward slash',    '$/ escaped opening dollar slashy',    '/$ escaped closing dollar slashy'].every { dollarSlashy.contains(it) }

char c1 = 'A'(1)assert c1 instanceof Characterdef c2 = 'B' as char(2)assert c2 instanceof Characterdef c3 = (char)'C'(3)assert c3 instanceof Character

// primitive typesbyte  b = 1char  c = 2short s = 3int   i = 4long  l = 5// infinite precisionBigInteger bi =  6

def a = 1assert a instanceof Integer// Integer.MAX_VALUEdef b = 2147483647assert b instanceof Integer// Integer.MAX_VALUE + 1def c = 2147483648assert c instanceof Long// Long.MAX_VALUEdef d = 9223372036854775807assert d instanceof Long// Long.MAX_VALUE + 1def e = 9223372036854775808assert e instanceof BigInteger

def na = -1assert na instanceof Integer// Integer.MIN_VALUEdef nb = -2147483648assert nb instanceof Integer// Integer.MIN_VALUE - 1def nc = -2147483649assert nc instanceof Long// Long.MIN_VALUEdef nd = -9223372036854775808assert nd instanceof Long// Long.MIN_VALUE - 1def ne = -9223372036854775809assert ne instanceof BigInteger

Numbers can also be represented in binary, octal, hexadecimal and decimal bases.

Binary literal

int xInt = 0b10101111assert xInt == 175short xShort = 0b11001001assert xShort == 201 as shortbyte xByte = 0b11assert xByte == 3 as bytelong xLong = 0b101101101101assert xLong == 2925lBigInteger xBigInteger = 0b111100100001assert xBigInteger == 3873gint xNegativeInt = -0b10101111assert xNegativeInt == -175

Octal literal

int xInt = 077assert xInt == 63short xShort = 011assert xShort == 9 as shortbyte xByte = 032assert xByte == 26 as bytelong xLong = 0246assert xLong == 166lBigInteger xBigInteger = 01111assert xBigInteger == 585gint xNegativeInt = -077assert xNegativeInt == -63

Hexadecimal literal

int xInt = 0x77assert xInt == 119short xShort = 0xaaassert xShort == 170 as shortbyte xByte = 0x3aassert xByte == 58 as bytelong xLong = 0xffffassert xLong == 65535lBigInteger xBigInteger = 0xaaaaassert xBigInteger == 43690gDouble xDouble = new Double('0x1.0p0')assert xDouble == 1.0dint xNegativeInt = -0x77assert xNegativeInt == -119

// primitive typesfloat  f = 1.234double d = 2.345// infinite precisionBigDecimal bd =  3.456

assert 1e3  ==  1_000.0assert 2E4  == 20_000.0assert 3e+1 ==     30.0assert 4E-2 ==      0.04assert 5e-1 ==      0.5

long creditCardNumber = 1234_5678_9012_3456Llong socialSecurityNumbers = 999_99_9999Ldouble monetaryAmount = 12_345_132.12long hexBytes = 0xFF_EC_DE_5Elong hexWords = 0xFFEC_DE5Elong maxLong = 0x7fff_ffff_ffff_ffffLlong alsoMaxLong = 9_223_372_036_854_775_807Llong bytes = 0b11010010_01101001_10010100_10010010

assert 42I == Integer.valueOf('42')assert 42i == Integer.valueOf('42') // lowercase i more readableassert 123L == Long.valueOf("123") // uppercase L more readableassert 2147483648 == Long.valueOf('2147483648') // Long type used, value too large for an Integerassert 456G == new BigInteger('456')assert 456g == new BigInteger('456')assert 123.45 == new BigDecimal('123.45') // default BigDecimal type usedassert .321 == new BigDecimal('.321')assert 1.200065D == Double.valueOf('1.200065')assert 1.234F == Float.valueOf('1.234')assert 1.23E23D == Double.valueOf('1.23E23')assert 0b1111L.class == Long // binaryassert 0xFFi.class == Integer // hexadecimalassert 034G.class == BigInteger // octal

The division operators/ (and/= for division and assignment) produce adouble resultif either operand is afloat ordouble, and aBigDecimal result otherwise(when both operands are any combination of an integral typeshort,char,byte,int,long,BigInteger orBigDecimal).

BigDecimal division is performed with thedivide() method if the division is exact(i.e. yielding a result that can be represented within the bounds of the same precision and scale),or using aMathContext with aprecisionof the maximum of the two operands' precision plus an extra precision of 10,and ascaleof the maximum of 10 and the maximum of the operands' scale.

The power operation is represented by the** operator, with two parameters: the base and the exponent.The result of the power operation depends on its operands, and the result of the operation(in particular if the result can be represented as an integral value).

The following rules are used by Groovy’s power operation to determine the resulting type:

• If the exponent is a decimal value

  • if the result can be represented as anInteger, then return anInteger

  • else if the result can be represented as aLong, then return aLong

  • otherwise return aDouble

• If the exponent is an integral value

  • if the exponent is strictly negative, then return anInteger,Long orDouble if the result value fits in that type

  • if the exponent is positive or zero

    • if the base is aBigDecimal, then return aBigDecimal result value

    • if the base is aBigInteger, then return aBigInteger result value

    • if the base is anInteger, then return anInteger if the result value fits in it, otherwise aBigInteger

    • if the base is aLong, then return aLong if the result value fits in it, otherwise aBigInteger

We can illustrate those rules with a few examples:

def primes = new int[] {2, 3, 5, 7, 11}assert primes.size() == 5 && primes.sum() == 28assert primes.class.name == '[I'def pets = new String[] {'cat', 'dog'}assert pets.size() == 2 && pets.sum() == 'catdog'assert pets.class.name == '[Ljava.lang.String;'// traditional Groovy alternative still supportedString[] groovyBooks = [ 'Groovy in Action', 'Making Java Groovy' ]assert groovyBooks.every{ it.contains('Groovy') }