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:
  • Constructor Details Link icon

  • Method Details Link icon

    • dotAll Link icon

      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 Link icon

      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 Link icon

      @Deprecated public static Matcher dotAllMatcher(String regex, String 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.13.0
    • removeAll Link icon

      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:
    • removeAll Link icon

      @Deprecated 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:
    • removeAll Link icon

      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:
    • removeFirst Link icon

      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:
    • removeFirst Link icon

      @Deprecated 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:
    • removeFirst Link icon

      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:
    • removePattern Link icon

      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:
    • removePattern Link icon

      @Deprecated 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:
    • replaceAll Link icon

      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:
    • replaceAll Link icon

      @Deprecated 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:
    • replaceAll Link icon

      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:
    • replaceFirst Link icon

      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:
    • replaceFirst Link icon

      @Deprecated 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:
    • replaceFirst Link icon

      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:
    • replacePattern Link icon

      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:
    • replacePattern Link icon

      @Deprecated 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: