org.apache.commons.lang3

## 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 and Description
    `RegExUtils()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static String` | `removeAll(String 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` | `removeFirst(String 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` | `removePattern(String text, String regex)` Removes each substring of the source String that matches the given regular expression using the DOTALL option.
    `static String` | `replaceAll(String 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` | `replaceFirst(String 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` | `replacePattern(String 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.

    - ### 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 String removeAll(String 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
      See Also:
        `replaceAll(String, 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(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:
        `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 String removeFirst(String 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
      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(String 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`
      See Also:
        `replacePattern(String, String, String)`, `String.replaceAll(String, String)`, `Pattern.DOTALL`

    - #### replaceAll

          public static String replaceAll(String 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

          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(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:
        `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(String 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
      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(String 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`
      See Also:
        `replaceAll(String, String, String)`, `String.replaceAll(String, String)`, `Pattern.DOTALL`

Copyright © 2001–2018 The Apache Software Foundation. All rights reserved.