1. Introduction
In this quick tutorial, we’ll learn how to remove the prefix from a string in Groovy.
First, we’ll look at what the String class offers for this purpose. After that, we’ll move on to regular expressions and see how we can use them to remove a prefix.
2. Using String Methods
Generally, Groovy is considered a dynamic language for the Java ecosystem. Therefore, we can still use every Java String class method along with new Groovy ones. However, for the removal of the prefix, there is still an absence of a straightforward method like removePrefix().
Removing of a prefix from Groovy strings consists of two steps: first confirmation and then removal. Both of these steps can be performed using the StringGroovyMethods class that offers many utility methods for string manipulations.
2.1. startsWith() Method
The startWith() method tests if a string starts with a specific prefix. It returns true if the prefix exists and false otherwise.
Let’s start with a groovy closure:
def "whenCasePrefixIsRemoved_thenReturnTrue"() {
given:
def trimPrefix = {
it.startsWith('Groovy-') ? it.minus('Groovy-') : it
}
when:
def actual = trimPrefix("Groovy-Tutorials at Baeldung")
def expected = "Tutorials at Baeldung"
then:
expected == actual
}
Once existence is confirmed, then we can also use the substring() method to remove it:
trimPrefix.substring('Groovy-'.length())
2.2. startsWithIgnoreCase() Method
The startsWith() method is case-sensitive. So, a manual effort is required to negate the effect of the case either by applying the toLowerCase() or toUpperCase() methods.
As the name suggests, the startsWithIgnoreCase() searches a prefix without case consideration. It returns true if a prefix exists and false otherwise.
Let’s look at how to use this method:
@Test
public void whenPrefixIsRemovedWithIgnoreCase_thenReturnTrue() {
String prefix = "groovy-"
String trimPrefix = "Groovy-Tutorials at Baeldung"
def actual
if(trimPrefix.startsWithIgnoreCase(prefix)) {
actual = trimPrefix.substring(prefix.length())
}
def expected = "Tutorials at Baeldung"
assertEquals(expected, actual)
}
2.3. startsWithAny() Method
The above solutions are useful when we have to check only one prefix. When it comes to checking multiple prefixes, Groovy also provides support to check multiple prefixes.
The startsWithAny() method checks if the CharSequence starts with any specified prefixes. Once the prefix is confirmed, we can apply logic according to requirements:
String trimPrefix = "Groovy-Tutorials at Baeldung"
if (trimPrefix.startsWithAny("Java", "Groovy", "Linux")) {
// logic to remove prefix
}
3. Using Regex
A regular expression is a powerful way to match or replace a pattern. Groovy has a pattern operator ~ that provides a simple way to create a java.util.regex.Pattern instance.
Let’s define a simple regular expression to remove a prefix:
def "whenPrefixIsRemovedUsingRegex_thenReturnTrue"() {
given:
def regex = ~"^([Gg])roovy-"
String trimPrefix = "Groovy-Tutorials at Baeldung"
when:
String actual = trimPrefix - regex
def expected = "Tutorials at Baeldung"
then:
expected == actual
}
The case-insensitive version of the above regular expression:
def regex = ~"^([Gg])roovy-"
The caret operator ^ will make sure that the specified substring exists at the start.
3.1. replaceFirst() Method
Using regular expressions along with native strings methods, we can perform very powerful tricks. The replaceFirst() method is one of these methods. It replaces the first occurrence that matches the given regular expression.
Let’s remove a prefix using the replaceFirst() method:
def "whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue"() {
given:
def regex = ~"^groovy"
String trimPrefix = "groovyTutorials at Baeldung's groovy page"
when:
String actual = trimPrefix.replaceFirst(regex, "")
def expected = "Tutorials at Baeldung's groovy page"
then:
expected == actual
}
3.2. replaceAll() Method
Just like replaceFirst(), the replaceAll() also accepts a regular expression and given replacement. It replaces each substring that matches the given criteria. To remove a prefix, we can use this method too.
Let’s use replaceAll() to replace a substring at the start of the string only:
def "whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue"() {
given:
String trimPrefix = "groovyTutorials at Baeldung groovy"
when:
String actual = trimPrefix.replaceAll(/^groovy/, "")
def expected = "Tutorials at Baeldung groovy"
then:
expected == actual
}
4. Conclusion
In this quick tutorial, we explored several ways to remove prefixes from a string. To confirm the existence of a prefix, we saw how to do this for both uppercase and lowercase strings.
At the same time, we’ve seen how to detect a prefix among many provided substrings. We also looked at multiple methods that can be used to remove a substring. Lastly, we briefly discussed the role of regex for this purpose.
As always, all the code examples can be found over on GitHub.
