Three Groovy String methods that will make your life Groovier!

How many times you tried to format some console text using printf, and you have to google " printf pad to right", etc.? I think I did that countless times in the past. Until I’ve found those three useful String methods in the Groovy SDK: padLeft, padRight, and center.

The first two are quite self-descriptive - they add padding on the left/right side, relative to the actual string length. So, for instance, when we call "abc" .padRight(10), seven spaces will be added after the last character in the string. The center method, on the other hand, places the string in the middle and adds equal paddings on both sides. For instance, "abc".center(7,"-") will produce a string like --abc--

Just look at the following example.

And here is the output in the console when running this simple Groovy script.

Using + operator to concatenate two strings is nothing special. Groovy, however, adds support for - (subtraction) and * (multiplication) operators as well.

The use case for - operator is simple. It creates a new string with the removed first occurrence of the right side string (if any). If the right side string occurs multiple times on the left side string, only the first one gets removed.

Here are some examples from the groovysh:

The minus operator may be much more useful when combined with the range operator. Let’s assume we have a string, and we need to create a new one by removing some range from the input string.

Clean and simple.

The multiplication operator * provides a way to repeat strings or characters without much hustle. Let’s say you are building a command line tool and you want to draw some ASCII art shapes. You can use a combination of * and + operators to draw a rectangle with a single line of Groovy code.

Groovy’s text translation method seems to be unknown to many programmers. Some of you might think that it is just an equivalent of good old String.replaceAll() method. Nothing could be further from the truth. Let’s look at a few examples.

Pfff, easy. Fair enough. What about this?

OK, so what happened here? In this second case, Groovy translated lower case letters from a to z to their representatives (letters at the same index position) from the range from z to a.

Here you can see that o translates to l, h translates to s, and so on.

Of course, you can use more fancy translations, like:

In this case replacement @-:a-[ translates to combination of two ranges: @-:, and a-[ which generates a list of the following characters:

As you can see, the tr method does not invent anything new. You could achieve something similar with regular expressions but less simply.

One more cool method I discovered quite recently thanks to one question posted on the Groovy Community Slack. Groovy String API has one handy yet straightforward method - count(charSequence). This method allows you to quickly discover how many occurrences of the given characters sequence exist in the input string. You can count single letters, as well as substrings, in a pretty efficient way.