Package org.apache.commons.lang3

## Class RegExUtils

- java.lang.Object
- - org.apache.commons.lang3.RegExUtils

    public class RegExUtils
    extends java.lang.Object

Helpers to process Strings using regular expressions.

Since:
  3.8
See Also:
  `Pattern`

### Constructor Summary

Constructors
`RegExUtils()`

### Method Summary

All Methods Static Methods Concrete Methods
`static java.lang.String` `removeAll​(java.lang.String text, java.lang.String regex)` Removes each substring of the text String that matches the given regular expression.
`static java.lang.String` `removeAll​(java.lang.String text, java.util.regex.Pattern regex)` Removes each substring of the text String that matches the given regular expression pattern.
`static java.lang.String` `removeFirst​(java.lang.String text, java.lang.String regex)` Removes the first substring of the text string that matches the given regular expression.
`static java.lang.String` `removeFirst​(java.lang.String text, java.util.regex.Pattern regex)` Removes the first substring of the text string that matches the given regular expression pattern.
`static java.lang.String` `removePattern​(java.lang.String text, java.lang.String regex)` Removes each substring of the source String that matches the given regular expression using the DOTALL option.
`static java.lang.String` `replaceAll​(java.lang.String text, java.lang.String regex, java.lang.String replacement)` Replaces each substring of the text String that matches the given regular expression with the given replacement.
`static java.lang.String` `replaceAll​(java.lang.String text, java.util.regex.Pattern regex, java.lang.String replacement)` Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.
`static java.lang.String` `replaceFirst​(java.lang.String text, java.lang.String regex, java.lang.String replacement)` Replaces the first substring of the text string that matches the given regular expression with the given replacement.
`static java.lang.String` `replaceFirst​(java.lang.String text, java.util.regex.Pattern regex, java.lang.String replacement)` Replaces the first substring of the text string that matches the given regular expression pattern with the given replacement.
`static java.lang.String` `replacePattern​(java.lang.String text, java.lang.String regex, java.lang.String replacement)` Replaces each substring of the source String that matches the given regular expression with the given replacement using the `Pattern.DOTALL` option.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### RegExUtils

    public RegExUtils()

### Method Detail

#### removeAll

    public static java.lang.String removeAll​(java.lang.String text,
                                             java.util.regex.Pattern regex)

Removes each substring of the text String that matches the given regular expression pattern.

This method is a `null` safe equivalent to:

- `pattern.matcher(text).replaceAll(StringUtils.EMPTY)`

A `null` reference passed to this method is a no-op.

     StringUtils.removeAll(null, *)      = null
     StringUtils.removeAll("any", (Pattern) null)  = "any"
     StringUtils.removeAll("any", Pattern.compile(""))    = "any"
     StringUtils.removeAll("any", Pattern.compile(".*"))  = ""
     StringUtils.removeAll("any", Pattern.compile(".+"))  = ""
     StringUtils.removeAll("abc", Pattern.compile(".?"))  = ""
     StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>"))      = "A\nB"
     StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("(?s)<.*>"))  = "AB"
     StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>", Pattern.DOTALL))  = "AB"
     StringUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]"))     = "ABC123"

Parameters:
  `text` - text to remove from, may be null
  `regex` - the regular expression to which this string is to be matched
Returns:
  the text with any removes processed, `null` if null String input
See Also:
  `replaceAll(String, Pattern, String)`, `Matcher.replaceAll(String)`, `Pattern`

#### removeAll

    public static java.lang.String removeAll​(java.lang.String text,
                                             java.lang.String regex)

Removes each substring of the text String that matches the given regular expression.

This method is a `null` safe equivalent to:

- `text.replaceAll(regex, StringUtils.EMPTY)`
- `Pattern.compile(regex).matcher(text).replaceAll(StringUtils.EMPTY)`

A `null` reference passed to this method is a no-op.

Unlike in the `removePattern(String, String)` method, the `Pattern.DOTALL` option is NOT automatically added. To use the DOTALL option prepend `"(?s)"` to the regex. DOTALL is also known as single-line mode in Perl.

     StringUtils.removeAll(null, *)      = null
     StringUtils.removeAll("any", (String) null)  = "any"
     StringUtils.removeAll("any", "")    = "any"
     StringUtils.removeAll("any", ".*")  = ""
     StringUtils.removeAll("any", ".+")  = ""
     StringUtils.removeAll("abc", ".?")  = ""
     StringUtils.removeAll("A<__>\n<__>B", "<.*>")      = "A\nB"
     StringUtils.removeAll("A<__>\n<__>B", "(?s)<.*>")  = "AB"
     StringUtils.removeAll("ABCabc123abc", "[a-z]")     = "ABC123"

Parameters:
  `text` - text to remove from, may be null
  `regex` - the regular expression to which this string is to be matched
Returns:
  the text with any removes processed, `null` if null String input
Throws:
  `java.util.regex.PatternSyntaxException` - if the regular expression's syntax is invalid
See Also:
  `replaceAll(String, String, String)`, `removePattern(String, String)`, `String.replaceAll(String, String)`, `Pattern`, `Pattern.DOTALL`

#### removeFirst

    public static java.lang.String removeFirst​(java.lang.String text,
                                               java.util.regex.Pattern regex)

Removes the first substring of the text string that matches the given regular expression pattern.

This method is a `null` safe equivalent to:

- `pattern.matcher(text).replaceFirst(StringUtils.EMPTY)`

A `null` reference passed to this method is a no-op.

     StringUtils.removeFirst(null, *)      = null
     StringUtils.removeFirst("any", (Pattern) null)  = "any"
     StringUtils.removeFirst("any", Pattern.compile(""))    = "any"
     StringUtils.removeFirst("any", Pattern.compile(".*"))  = ""
     StringUtils.removeFirst("any", Pattern.compile(".+"))  = ""
     StringUtils.removeFirst("abc", Pattern.compile(".?"))  = "bc"
     StringUtils.removeFirst("A<__>\n<__>B", Pattern.compile("<.*>"))      = "A\n<__>B"
     StringUtils.removeFirst("A<__>\n<__>B", Pattern.compile("(?s)<.*>"))  = "AB"
     StringUtils.removeFirst("ABCabc123", Pattern.compile("[a-z]"))          = "ABCbc123"
     StringUtils.removeFirst("ABCabc123abc", Pattern.compile("[a-z]+"))      = "ABC123abc"

Parameters:
  `text` - text to remove from, may be null
  `regex` - the regular expression pattern to which this string is to be matched
Returns:
  the text with the first replacement processed, `null` if null String input
See Also:
  `replaceFirst(String, Pattern, String)`, `Matcher.replaceFirst(String)`, `Pattern`

#### removeFirst

    public static java.lang.String removeFirst​(java.lang.String text,
                                               java.lang.String regex)

Removes the first substring of the text string that matches the given regular expression.

This method is a `null` safe equivalent to:

- `text.replaceFirst(regex, StringUtils.EMPTY)`
- `Pattern.compile(regex).matcher(text).replaceFirst(StringUtils.EMPTY)`

A `null` reference passed to this method is a no-op.

The `Pattern.DOTALL` option is NOT automatically added. To use the DOTALL option prepend `"(?s)"` to the regex. DOTALL is also known as single-line mode in Perl.

     StringUtils.removeFirst(null, *)      = null
     StringUtils.removeFirst("any", (String) null)  = "any"
     StringUtils.removeFirst("any", "")    = "any"
     StringUtils.removeFirst("any", ".*")  = ""
     StringUtils.removeFirst("any", ".+")  = ""
     StringUtils.removeFirst("abc", ".?")  = "bc"
     StringUtils.removeFirst("A<__>\n<__>B", "<.*>")      = "A\n<__>B"
     StringUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>")  = "AB"
     StringUtils.removeFirst("ABCabc123", "[a-z]")          = "ABCbc123"
     StringUtils.removeFirst("ABCabc123abc", "[a-z]+")      = "ABC123abc"

Parameters:
  `text` - text to remove from, may be null
  `regex` - the regular expression to which this string is to be matched
Returns:
  the text with the first replacement processed, `null` if null String input
Throws:
  `java.util.regex.PatternSyntaxException` - if the regular expression's syntax is invalid
See Also:
  `replaceFirst(String, String, String)`, `String.replaceFirst(String, String)`, `Pattern`, `Pattern.DOTALL`

#### removePattern

    public static java.lang.String removePattern​(java.lang.String text,
                                                 java.lang.String regex)

Removes each substring of the source String that matches the given regular expression using the DOTALL option.

This call is a `null` safe equivalent to:

- `text.replaceAll(&quot;(?s)&quot; + regex, StringUtils.EMPTY)`
- `Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(StringUtils.EMPTY)`

A `null` reference passed to this method is a no-op.

     StringUtils.removePattern(null, *)       = null
     StringUtils.removePattern("any", (String) null)   = "any"
     StringUtils.removePattern("A<__>\n<__>B", "<.*>")  = "AB"
     StringUtils.removePattern("ABCabc123", "[a-z]")    = "ABC123"

Parameters:
  `text` - the source string
  `regex` - the regular expression to which this string is to be matched
Returns:
  The resulting `String`
See Also:
  `replacePattern(String, String, String)`, `String.replaceAll(String, String)`, `Pattern.DOTALL`

#### replaceAll

    public static java.lang.String replaceAll​(java.lang.String text,
                                              java.util.regex.Pattern regex,
                                              java.lang.String replacement)

Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.

This method is a `null` safe equivalent to:

- `pattern.matcher(text).replaceAll(replacement)`

A `null` reference passed to this method is a no-op.

     StringUtils.replaceAll(null, *, *)       = null
     StringUtils.replaceAll("any", (Pattern) null, *)   = "any"
     StringUtils.replaceAll("any", *, null)   = "any"
     StringUtils.replaceAll("", Pattern.compile(""), "zzz")    = "zzz"
     StringUtils.replaceAll("", Pattern.compile(".*"), "zzz")  = "zzz"
     StringUtils.replaceAll("", Pattern.compile(".+"), "zzz")  = ""
     StringUtils.replaceAll("abc", Pattern.compile(""), "ZZ")  = "ZZaZZbZZcZZ"
     StringUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>"), "z")                 = "z\nz"
     StringUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>", Pattern.DOTALL), "z") = "z"
     StringUtils.replaceAll("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z")             = "z"
     StringUtils.replaceAll("ABCabc123", Pattern.compile("[a-z]"), "_")       = "ABC___123"
     StringUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), "_")  = "ABC_123"
     StringUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), "")   = "ABC123"
     StringUtils.replaceAll("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2")  = "Lorem_ipsum_dolor_sit"

Parameters:
  `text` - text to search and replace in, may be null
  `regex` - the regular expression pattern to which this string is to be matched
  `replacement` - the string to be substituted for each match
Returns:
  the text with any replacements processed, `null` if null String input
See Also:
  `Matcher.replaceAll(String)`, `Pattern`

#### replaceAll

    public static java.lang.String replaceAll​(java.lang.String text,
                                              java.lang.String regex,
                                              java.lang.String replacement)

Replaces each substring of the text String that matches the given regular expression with the given replacement.

This method is a `null` safe equivalent to:

- `text.replaceAll(regex, replacement)`
- `Pattern.compile(regex).matcher(text).replaceAll(replacement)`

A `null` reference passed to this method is a no-op.

Unlike in the `replacePattern(String, String, String)` method, the `Pattern.DOTALL` option is NOT automatically added. To use the DOTALL option prepend `"(?s)"` to the regex. DOTALL is also known as single-line mode in Perl.

     StringUtils.replaceAll(null, *, *)       = null
     StringUtils.replaceAll("any", (String) null, *)   = "any"
     StringUtils.replaceAll("any", *, null)   = "any"
     StringUtils.replaceAll("", "", "zzz")    = "zzz"
     StringUtils.replaceAll("", ".*", "zzz")  = "zzz"
     StringUtils.replaceAll("", ".+", "zzz")  = ""
     StringUtils.replaceAll("abc", "", "ZZ")  = "ZZaZZbZZcZZ"
     StringUtils.replaceAll("<__>\n<__>", "<.*>", "z")      = "z\nz"
     StringUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z")  = "z"
     StringUtils.replaceAll("ABCabc123", "[a-z]", "_")       = "ABC___123"
     StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
     StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
     StringUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"

Parameters:
  `text` - text to search and replace in, may be null
  `regex` - the regular expression to which this string is to be matched
  `replacement` - the string to be substituted for each match
Returns:
  the text with any replacements processed, `null` if null String input
Throws:
  `java.util.regex.PatternSyntaxException` - if the regular expression's syntax is invalid
See Also:
  `replacePattern(String, String, String)`, `String.replaceAll(String, String)`, `Pattern`, `Pattern.DOTALL`

#### replaceFirst

    public static java.lang.String replaceFirst​(java.lang.String text,
                                                java.util.regex.Pattern regex,
                                                java.lang.String replacement)

Replaces the first substring of the text string that matches the given regular expression pattern with the given replacement.

This method is a `null` safe equivalent to:

- `pattern.matcher(text).replaceFirst(replacement)`

A `null` reference passed to this method is a no-op.

     StringUtils.replaceFirst(null, *, *)       = null
     StringUtils.replaceFirst("any", (Pattern) null, *)   = "any"
     StringUtils.replaceFirst("any", *, null)   = "any"
     StringUtils.replaceFirst("", Pattern.compile(""), "zzz")    = "zzz"
     StringUtils.replaceFirst("", Pattern.compile(".*"), "zzz")  = "zzz"
     StringUtils.replaceFirst("", Pattern.compile(".+"), "zzz")  = ""
     StringUtils.replaceFirst("abc", Pattern.compile(""), "ZZ")  = "ZZabc"
     StringUtils.replaceFirst("<__>\n<__>", Pattern.compile("<.*>"), "z")      = "z\n<__>"
     StringUtils.replaceFirst("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z")  = "z"
     StringUtils.replaceFirst("ABCabc123", Pattern.compile("[a-z]"), "_")          = "ABC_bc123"
     StringUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), "_")  = "ABC_123abc"
     StringUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), "")   = "ABC123abc"
     StringUtils.replaceFirst("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2")  = "Lorem_ipsum  dolor   sit"

Parameters:
  `text` - text to search and replace in, may be null
  `regex` - the regular expression pattern to which this string is to be matched
  `replacement` - the string to be substituted for the first match
Returns:
  the text with the first replacement processed, `null` if null String input
See Also:
  `Matcher.replaceFirst(String)`, `Pattern`

#### replaceFirst

    public static java.lang.String replaceFirst​(java.lang.String text,
                                                java.lang.String regex,
                                                java.lang.String replacement)

Replaces the first substring of the text string that matches the given regular expression with the given replacement.

This method is a `null` safe equivalent to:

- `text.replaceFirst(regex, replacement)`
- `Pattern.compile(regex).matcher(text).replaceFirst(replacement)`

A `null` reference passed to this method is a no-op.

The `Pattern.DOTALL` option is NOT automatically added. To use the DOTALL option prepend `"(?s)"` to the regex. DOTALL is also known as single-line mode in Perl.

     StringUtils.replaceFirst(null, *, *)       = null
     StringUtils.replaceFirst("any", (String) null, *)   = "any"
     StringUtils.replaceFirst("any", *, null)   = "any"
     StringUtils.replaceFirst("", "", "zzz")    = "zzz"
     StringUtils.replaceFirst("", ".*", "zzz")  = "zzz"
     StringUtils.replaceFirst("", ".+", "zzz")  = ""
     StringUtils.replaceFirst("abc", "", "ZZ")  = "ZZabc"
     StringUtils.replaceFirst("<__>\n<__>", "<.*>", "z")      = "z\n<__>"
     StringUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z")  = "z"
     StringUtils.replaceFirst("ABCabc123", "[a-z]", "_")          = "ABC_bc123"
     StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_")  = "ABC_123abc"
     StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "")   = "ABC123abc"
     StringUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum  dolor   sit"

Parameters:
  `text` - text to search and replace in, may be null
  `regex` - the regular expression to which this string is to be matched
  `replacement` - the string to be substituted for the first match
Returns:
  the text with the first replacement processed, `null` if null String input
Throws:
  `java.util.regex.PatternSyntaxException` - if the regular expression's syntax is invalid
See Also:
  `String.replaceFirst(String, String)`, `Pattern`, `Pattern.DOTALL`

#### replacePattern

    public static java.lang.String replacePattern​(java.lang.String text,
                                                  java.lang.String regex,
                                                  java.lang.String replacement)

Replaces each substring of the source String that matches the given regular expression with the given replacement using the `Pattern.DOTALL` option. DOTALL is also known as single-line mode in Perl.

This call is a `null` safe equivalent to:

- `text.replaceAll(&quot;(?s)&quot; + regex, replacement)`
- `Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement)`

A `null` reference passed to this method is a no-op.

     StringUtils.replacePattern(null, *, *)       = null
     StringUtils.replacePattern("any", (String) null, *)   = "any"
     StringUtils.replacePattern("any", *, null)   = "any"
     StringUtils.replacePattern("", "", "zzz")    = "zzz"
     StringUtils.replacePattern("", ".*", "zzz")  = "zzz"
     StringUtils.replacePattern("", ".+", "zzz")  = ""
     StringUtils.replacePattern("<__>\n<__>", "<.*>", "z")       = "z"
     StringUtils.replacePattern("ABCabc123", "[a-z]", "_")       = "ABC___123"
     StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
     StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
     StringUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"

Parameters:
  `text` - the source string
  `regex` - the regular expression to which this string is to be matched
  `replacement` - the string to be substituted for each match
Returns:
  The resulting `String`
See Also:
  `replaceAll(String, String, String)`, `String.replaceAll(String, String)`, `Pattern.DOTALL`