The following binary arithmetic operators are available in Groovy:

Here are a few examples of usage of those operators:

The+ and- operators are also available as unary operators:

In terms of unary arithmetics operators, the++ (increment) and-- (decrement) operators are available,both in prefix and postfix notation:

For the unary not operator on Booleans, seeConditional operators.

The binary arithmetic operators we have seen above are also available in an assignment form:

• +=

• -=

• *=

• /=

• %=

• **=

Let’s see them in action:

assert 1 + 2 == 3assert 3 != 4assert -2 < 3assert 2 <= 2assert 3 <= 4assert 5 > 1assert 5 >= -2

import groovy.transform.EqualsAndHashCode@EqualsAndHashCodeclass Creature { String type }def cat = new Creature(type: 'cat')def copyCat = catdef lion = new Creature(type: 'cat')assert cat.equals(lion) // Java logical equalityassert cat == lion      // Groovy shorthand operatorassert cat.is(copyCat)  // Groovy identityassert cat === copyCat  // operator shorthandassert cat !== lion     // negated operator shorthand

assert !false(1)assert true && true(2)assert true || false(3)

The logical "not" has a higher priority than the logical "and".

The logical "and" has a higher priority than the logical "or".

The logical|| operator supports short-circuiting: if the left operand is true, it knows that the result will be true in any case, so it won’t evaluate the right operand.The right operand will be evaluated only if the left operand is false.

Likewise for the logical&& operator: if the left operand is false, it knows that the result will be false in any case, so it won’t evaluate the right operand.The right operand will be evaluated only if the left operand is true.

Groovy offers four bitwise operators:

• &: bitwise "and"

• |: bitwise "or"

• ^: bitwise "xor" (exclusive "or")

• ~: bitwise negation

Bitwise operators can be applied on arguments which are of typebyte,short,int,long, orBigInteger.If one of the arguments is aBigInteger, the result will be of typeBigInteger;otherwise, if one of the arguments is along, the result will be of typelong;otherwise, the result will be of typeint:

It’s worth noting that the internal representation of primitive types follow theJava Language Specification. In particular,primitive types are signed, meaning that for a bitwise negation, it is always good to use a mask to retrieve only the necessary bits.

In Groovy, bitwise operators areoverloadable, meaning that you can define the behavior of those operators for any kind of object.

Groovy offers three bit shift operators:

• <<: left shift

• >>: right shift

• >>>: right shift unsigned

All three operators are applicable where the left argument is of typebyte,short,int, orlong.The first two operators can also be applied where the left argument is of typeBigInteger.If the left argument is aBigInteger, the result will be of typeBigInteger;otherwise, if the left argument is along, the result will be of typelong;otherwise, the result will be of typeint:

In Groovy, bit shift operators areoverloadable, meaning that you can define the behavior of those operators for any kind of object.

The "not" operator is represented with an exclamation mark (!) and inverts the result of the underlying boolean expression. Inparticular, it is possible to combine thenot operator with theGroovy truth:

The ternary operator is a shortcut expression that is equivalent to an if/else branch assigning some value to a variable.

Instead of:

You can write:

The ternary operator is also compatible with theGroovy truth, so you can make it even simpler:

The "Elvis operator" is a shortening of the ternary operator. One instance of where this is handy is for returninga 'sensible default' value if an expression resolves tofalse-ish (as inGroovy truth). A simple example might look like this:

Usage of the Elvis operator reduces the verbosity of your code and reduces the risks of errors in case of refactorings,by removing the need to duplicate the expression which is tested in both the condition and the positive return value.

Groovy 3.0.0 introduces the Elvis operator, for example:

The Safe Navigation operator is used to avoid aNullPointerException. Typically when you have a reference to an objectyou might need to verify that it is notnull before accessing methods or properties of the object. To avoid this, the safenavigation operator will simply returnnull instead of throwing an exception, like so:

Normally in Groovy, when you write code like this:

Theuser.name call triggers a call to the property of the same name, that is to say, here, to the getter forname. Ifyou want to retrieve the field instead of calling the getter, you can use the direct field access operator:

The method pointer operator (.&) can be used to store a reference to a method in a variable,in order to call it later:

There are multiple advantages in using method pointers. First of all, the type of such a method pointer isagroovy.lang.Closure, so it can be used in any place a closure would be used. In particular, it is suitable toconvert an existing method for the needs of the strategy pattern:

Method pointers are bound by the receiver and a method name. Arguments are resolved at runtime, meaning that if you havemultiple methods with the same name, the syntax is not different, only resolution of the appropriate method to be calledwill be done at runtime:

To align with Java 8 method reference expectations, in Groovy 3 and above, you can usenew as themethod name to obtain a method pointer to the constructor:

Also in Groovy 3 and above, you can obtain a method pointer to an instance method of a class.This method pointer takes an additional parameter being the receiver instance toinvoke the method on:

For backwards compatibility, any static methods that happen to have the correctparameters for the call will be given precedence over instance methods for this case.

The Parrot parser in Groovy 3+ supports the Java 8+ method reference operator.The method reference operator (::) can be used to reference a method or constructorin contexts expecting a functional interface. This overlaps somewhat with the functionalityprovided by Groovy’s method pointer operator. Indeed, for dynamic Groovy, the methodreference operator is just an alias for the method pointer operator.For static Groovy, the operator results in bytecode similar to the bytecodethat Java would produce for the same context.

Some examples highlighting various supported method reference cases are shown in the following script:

Some examples highlighting various supported constructor reference cases are shown in the following script:

The pattern operator (~) provides a simple way to create ajava.util.regex.Pattern instance:

while in general, you find the pattern operator with an expression in a slashy-string, it can be used with any kind ofString in Groovy:

Alternatively to building a pattern, you can use the find operator=~ to directly create ajava.util.regex.Matcher instance:

Since aMatcher coerces to aboolean by calling itsfind method, the=~ operator is consistent with the simpleuse of Perl’s=~ operator, when it appears as a predicate (inif,?:, etc.). When the intent is to iterate overmatches of the specified pattern (inwhile, etc.) callfind() directly on the matcher or use theiterator DGM.

The match operator (==~) is a slight variation of the find operator, that does not return aMatcher but a booleanand requires a strict match of the input string:

Typically, the match operator is used when the pattern involves a single exact match, otherwisethe find operator might be more useful.

The Spread-dot Operator (*.), often abbreviated to just Spread Operator, is used to invoke an action on all itemsof an aggregate object. It is equivalent to calling the action on each item and collecting the result into a list:

The expressioncars*.make is equivalent tocars.collect{ it.make }.Groovy’s GPath notation allows a short-cut when the referenced propertyisn’t a property of the containing list, in that case it is automaticallyspread. In the previously mentioned case, the expressioncars.make canbe used, though retaining the explicit spread-dot operator is often recommended.

The spread operator is null-safe, meaning that if an element of the collection is null,it will return null instead of throwing aNullPointerException:

The spread operator can be used on any class which implements theIterable interface:

Use multiple invocations of the spread-dot operator (herecars*.models*.name) whenworking with aggregates of data structures which themselves contain aggregates:

Consider using thecollectNested DGM method instead of the spread-dot operator for collections of collections:

8.1.1. Spreading method arguments

int function(int x, int y, int z) {    x*y+z}

def args = [4,5,6]

assert function(*args) == 26

args = [4]assert function(*args,5,6) == 26

8.1.2. Spread list elements

def items = [4,5](1)def list = [1,2,3,*items,6](2)assert list == [1,2,3,4,5,6](3)

8.1.3. Spread map elements

def m1 = [c:3, d:4](1)def map = [a:1, b:2, *:m1](2)assert map == [a:1, b:2, c:3, d:4](3)

def m1 = [c:3, d:4](1)def map = [a:1, b:2, *:m1, d: 8](2)assert map == [a:1, b:2, c:3, d:8](3)

Groovy supports the concept of ranges and provides a notation (..) to create ranges of objects:

Ranges implementation is lightweight, meaning that only the lower and upper bounds are stored. You can create a rangefrom anyComparable object that hasnext() andprevious() methods to determine the next / previous item in the range.For example, you can create a range of characters this way:

The spaceship operator (<=>) delegates to thecompareTo method:

The subscript operator is a shorthand notation forgetAt orputAt, depending on whether you find it onthe left hand side or the right hand side of an assignment:

The subscript operator, in combination with a custom implementation ofgetAt/putAt is a convenient way for destructuringobjects:

Groovy 3.0.0 introduces safe indexing operator, i.e.?[], which is similar to?.. For example:

The membership operator (in) is equivalent to calling theisCase method. In the context of aList, it is equivalentto callingcontains, like in the following example:

In Groovy, using== to test equality is different from using the same operator in Java. In Groovy, it is callingequals.If you want to compare reference equality, you should useis like in the following example:

The coercion operator (as) is a variant of casting. Coercion converts object from one type to anotherwithout thembeing compatible for assignment. Let’s take an example:

This can be fixed by usingcoercion instead:

When an object is coerced into another, unless the target type is the same as the source type, coercion will return anew object. The rules of coercion differ depending on the source and target types, and coercion may fail if no conversionrules are found. Custom conversion rules may be implemented thanks to theasType method:

The diamond operator (<>) is a syntactic sugar only operator added to support compatibility with the operator of thesame name in Java 7. It is used to indicate that generic types should be inferred from the declaration:

In dynamic Groovy, this is totally unused. In statically type checked Groovy, it is also optional since the Groovytype checker performs type inference whether this operator is present or not.

The call operator() is used to call a method namedcall implicitly. For any object which defines acall method, you can omit the.call part and use the call operator instead:

class Bucket {    int size    Bucket(int size) { this.size = size }    Bucket plus(Bucket other) {(1)        return new Bucket(this.size + other.size)    }}

def b1 = new Bucket(4)def b2 = new Bucket(11)assert (b1 + b2).size == 15(1)

assert (b1 + 11).size == 15

Bucket plus(int capacity) {    return new Bucket(this.size + capacity)}