Groovy 5 adds the extension methods getExtension and getBaseName to the File and Path classes.
You can invoke them as properties for a File and Path objects.
Also the asBoolean method is added.
This mean you can use a File or Path instance in a boolean context.
If the underlying file exists true is returned and false otherwise.
Groovy (and Java) support using names for groups in regular expressions.
The name of the group is defined using the syntax ?<name> where name must be replaced with the actual group name.
This is very useful, because you can use the group name to access the value that is captured by the defined regular expression in a java.util.regex.Matcher object.
Groovy supports for a long time accessing a group using the index operator.
Since Groovy 5 you can use the name of the group to access the value as well.
You can specify the name between square brackets ([<name>]) or use the name as property.
Since Java 9 the methods requireNonNullElse and requireNonNullElseGet are part of the java.util.Objects class.
The method requireNonNullElse accepts two arguments.
The first argument is an object that will be returned if that object is not null.
The second argument is an object to be returned when the first argument is null.
With this method you can replace the following ternary operator if (a != null) ? a : b (or if (a == null) ? b : a) with Objects.requireNonNullElse(a, b).
The method requireNonNullElseGet allows to define a Supplier function as second argument.
The Supplier is only invoked when the first argument is null, so it is lazy and will only be invoked when the first argument is null.
Groovy already has a lot of extra methods for Stream classes.
With Groovy 5 the getAt method is added as a terminal operation.
You can now use the [] syntax to get an item from a Stream from a specific position.
The argument is the index of the item or a range with the start and end index of the items to get.
Since Groovy 1.8.2 the next and previous methods are added to the Character class.
When you invoke the method next on a char or Character instance the next character is returned.
And when you use the previous method the previous character is returned.
Groovy 5 adds an overloaded version of the next and previous method that accepts an int argument.
With this argument you can specify the number of characters to skip before returning the next or previous character. For example 'a'.next(2) return 'c' and 'c'.previous(2) returns 'a'.
Groovy supports operator overloading since the start.
Operator overloading is implemented by an actual method signature that maps to an operator.
For example an object with a plus method can be used with the + operator.
There is a list of methods and operators available on the Groovy website.
As long as an object has a method with a name that Groovy understands the corresponding operator can be used in Groovy code.
This is even true for Java objects.
Since Groovy 5 you can use the groovy.transform.OperatorRename annotation on classes, methods or constructors to map other method names to the Groovy operator overloading method names.
This is very useful for third-party classes that you cannot change, but still want to use simple operators in Groovy code.
You can reassign a method name to the following methods so an operator can be used: plus, minus, multiply, div, remainder, power, leftShift, rightShift, rightShiftUnassigned, and, or, xor, compareTo.
Suppose you use a class with an add method and want to use the + operator for this method.
The following annotation can be used @OperatorRename(plus = 'add') for a method and inside the method you can use the + operator instead of the add method of the class.
Since Groovy 1.8.3 Groovy has an implies() method for Boolean types.
Groovy 5 adds an operator ==> for this method so you have a shorter way to express a logical implication.
A logical implication is a logical function that can be expressed as P ==> Q.
You can read this as P implies Q or if P than Q.
This expression is true in every case except when P is true, but Q is false.
The following truth table shows the interpretaton of the logical implication operator:
| P | Q | P ==> Q |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
Groovy 5 adds support for using an index variable in a for-in loop. You must define an extra variable as first argument of the for loop. This variable will be used as index variable. For each iteration of the code in the for-in loop the value of this index variable is incremented by 1. You can use this value in the for loop.
Groovy 5 adds a new utility method to create an ascii bar chart.
You can use the bar method in the org.codehaus.groovy.util.StringUtil class.
You can pass a value, a minimum and maximum value and optinally specify the width of the bar chart.
The result is a String value consisting of a number of "blocks".
A block could be whole, but also 1/8 eights of the block are used to get a nice looking bar chart.
How many of these values are needed is based on the input arguments.
With this method you have a nice way to format number values on a command-line.
Groovy is known for exending standard Java classes with extra methods or extra arguments for existing methods.
Since Groovy 5 you can use a range as argument for the List.subList method.
The range is used to determine the begin and end index of the original List instance to return.