Package org.apache.commons.lang3

Class RegExUtils

  • public class RegExUtils
extends java.lang.Object

    Helpers to process Strings using regular expressions.

    Since:
    3.8
    See Also:
    Pattern

    • Constructor Summary

      Constructors 
      Constructor Description
      RegExUtils()  

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      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