RegExUtils (Apache Commons Lang 3.20.0 API)
Description: declaration: package: org.apache.commons.lang3, class: RegExUtils

# Class RegExUtils

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

public class RegExUtils extends Object
Helpers to process Strings using regular expressions.

Since:
  3.8
See Also:
  - `Pattern`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `RegExUtils()`
  Deprecated.
  TODO Make private in 4.0.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static Pattern`
  `dotAll(String regex)`
  Compiles the given regular expression into a pattern with the `Pattern.DOTALL` flag.
  `static Matcher`
  `dotAllMatcher(String regex, CharSequence text)`
  Compiles the given regular expression into a pattern with the `Pattern.DOTALL` flag, then creates a matcher that will match the given text against this pattern.
  `static Matcher`
  `dotAllMatcher(String regex, String text)`
  Deprecated.
  Use `dotAllMatcher(String, CharSequence)`.
  `static String`
  `removeAll(CharSequence text, Pattern regex)`
  Removes each substring of the text String that matches the given regular expression pattern.
  `static String`
  `removeAll(String text, String regex)`
  Removes each substring of the text String that matches the given regular expression.
  `static String`
  `removeAll(String text, Pattern regex)`
  Deprecated.
  Use `removeAll(CharSequence, Pattern)`.
  `static String`
  `removeFirst(CharSequence text, Pattern regex)`
  Removes the first substring of the text string that matches the given regular expression pattern.
  `static String`
  `removeFirst(String text, String regex)`
  Removes the first substring of the text string that matches the given regular expression.
  `static String`
  `removeFirst(String text, Pattern regex)`
  Deprecated.
  Use `removeFirst(CharSequence, Pattern)`.
  `static String`
  `removePattern(CharSequence text, String regex)`
  Removes each substring of the source String that matches the given regular expression using the DOTALL option.
  `static String`
  `removePattern(String text, String regex)`
  Deprecated.
  Use `removePattern(CharSequence, String)`.
  `static String`
  `replaceAll(CharSequence text, Pattern regex, String replacement)`
  Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.
  `static String`
  `replaceAll(String text, String regex, String replacement)`
  Replaces each substring of the text String that matches the given regular expression with the given replacement.
  `static String`
  `replaceAll(String text, Pattern regex, String replacement)`
  Deprecated.
  Use `replaceAll(CharSequence, Pattern, String)`.
  `static String`
  `replaceFirst(CharSequence text, Pattern regex, String replacement)`
  Replaces the first substring of the text string that matches the given regular expression pattern with the given replacement.
  `static String`
  `replaceFirst(String text, String regex, String replacement)`
  Replaces the first substring of the text string that matches the given regular expression with the given replacement.
  `static String`
  `replaceFirst(String text, Pattern regex, String replacement)`
  Deprecated.
  Use `replaceFirst(CharSequence, Pattern, String)`.
  `static String`
  `replacePattern(CharSequence text, String regex, String replacement)`
  Replaces each substring of the source String that matches the given regular expression with the given replacement using the `Pattern.DOTALL` option.
  `static String`
  `replacePattern(String text, String regex, String replacement)`
  Deprecated.
  Use `replacePattern(CharSequence, String, String)`.

  ### Methods inherited from class Object

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

- ## Constructor Details

  - ### RegExUtils

    @Deprecated public RegExUtils()
    Deprecated.
    TODO Make private in 4.0.
    Make private in 4.0.

- ## Method Details

  - ### dotAll

    public static Pattern dotAll(String regex)
    Compiles the given regular expression into a pattern with the `Pattern.DOTALL` flag.
    Parameters:
      `regex` - The expression to be compiled.
    Returns:
      the given regular expression compiled into a pattern with the `Pattern.DOTALL` flag.
    Since:
      3.13.0

  - ### dotAllMatcher

    public static Matcher dotAllMatcher(String regex, CharSequence text)
    Compiles the given regular expression into a pattern with the `Pattern.DOTALL` flag, then creates a matcher that will match the given text against this pattern.
    Parameters:
      `regex` - The expression to be compiled.
      `text` - The character sequence to be matched.
    Returns:
      A new matcher for this pattern.
    Since:
      3.18.0

  - ### dotAllMatcher

    @Deprecated public static Matcher dotAllMatcher(String regex, String text)
    Deprecated.
    Use `dotAllMatcher(String, CharSequence)`.
    Compiles the given regular expression into a pattern with the `Pattern.DOTALL` flag, then creates a matcher that will match the given text against this pattern.
    Parameters:
      `regex` - The expression to be compiled.
      `text` - The character sequence to be matched.
    Returns:
      A new matcher for this pattern.
    Since:
      3.13.0

  - ### removeAll

    public static String removeAll(CharSequence text, 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.
    Since:
      3.18.0
    See Also:
      - `replaceAll(CharSequence, Pattern, String)`
      - `Matcher.replaceAll(String)`
      - `Pattern`

  - ### removeAll

    @Deprecated public static String removeAll(String text, Pattern regex)
    Deprecated.
    Use `removeAll(CharSequence, Pattern)`.
    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(CharSequence, Pattern, String)`
      - `Matcher.replaceAll(String)`
      - `Pattern`

  - ### removeAll

    public static String removeAll(String text, 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(CharSequence, 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:
      `PatternSyntaxException` - if the regular expression's syntax is invalid.
    See Also:
      - `replaceAll(String, String, String)`
      - `removePattern(CharSequence, String)`
      - `String.replaceAll(String, String)`
      - `Pattern`
      - `Pattern.DOTALL`

  - ### removeFirst

    public static String removeFirst(CharSequence text, 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.
    Since:
      3.18.0
    See Also:
      - `replaceFirst(String, Pattern, String)`
      - `Matcher.replaceFirst(String)`
      - `Pattern`

  - ### removeFirst

    @Deprecated public static String removeFirst(String text, Pattern regex)
    Deprecated.
    Use `removeFirst(CharSequence, Pattern)`.
    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 String removeFirst(String text, 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:
      `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 String removePattern(CharSequence text, 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`.
    Since:
      3.18.0
    See Also:
      - `replacePattern(CharSequence, String, String)`
      - `String.replaceAll(String, String)`
      - `Pattern.DOTALL`

  - ### removePattern

    @Deprecated public static String removePattern(String text, String regex)
    Deprecated.
    Use `removePattern(CharSequence, String)`.
    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(CharSequence, String, String)`
      - `String.replaceAll(String, String)`
      - `Pattern.DOTALL`

  - ### replaceAll

    public static String replaceAll(CharSequence text, Pattern regex, 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

    @Deprecated public static String replaceAll(String text, Pattern regex, String replacement)
    Deprecated.
    Use `replaceAll(CharSequence, Pattern, String)`.
    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 String replaceAll(String text, String regex, 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(CharSequence, 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:
      `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 String replaceFirst(CharSequence text, Pattern regex, 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.
    Since:
      3.18.0
    See Also:
      - `Matcher.replaceFirst(String)`
      - `Pattern`

  - ### replaceFirst

    @Deprecated public static String replaceFirst(String text, Pattern regex, String replacement)
    Deprecated.
    Use `replaceFirst(CharSequence, Pattern, String)`.
    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 String replaceFirst(String text, String regex, 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:
      `PatternSyntaxException` - if the regular expression's syntax is invalid.
    See Also:
      - `String.replaceFirst(String, String)`
      - `Pattern`
      - `Pattern.DOTALL`

  - ### replacePattern

    public static String replacePattern(CharSequence text, String regex, 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`.
    Since:
      3.18.0
    See Also:
      - `replaceAll(String, String, String)`
      - `String.replaceAll(String, String)`
      - `Pattern.DOTALL`

  - ### replacePattern

    @Deprecated public static String replacePattern(String text, String regex, String replacement)
    Deprecated.
    Use `replacePattern(CharSequence, String, String)`.
    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`