How to Remove a Prefix From Strings in Groovy

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.