Repository: commons-lang Updated Branches: refs/heads/master 44b6d2ead -> bcc4f82a7
[LANG-1238] Add RegexUtils class instead of overloadinh methods in StringUtils that take a regex to take precompiled Pattern. Sort methods. Project: http://git-wip-us.apache.org/repos/asf/commons-lang/repo Commit: http://git-wip-us.apache.org/repos/asf/commons-lang/commit/bcc4f82a Tree: http://git-wip-us.apache.org/repos/asf/commons-lang/tree/bcc4f82a Diff: http://git-wip-us.apache.org/repos/asf/commons-lang/diff/bcc4f82a Branch: refs/heads/master Commit: bcc4f82a7aca3fe72142bd8d9ab3ac6c9d4d2767 Parents: 44b6d2e Author: Gary Gregory <garydgreg...@gmail.com> Authored: Thu May 17 17:15:19 2018 -0600 Committer: Gary Gregory <garydgreg...@gmail.com> Committed: Thu May 17 17:15:19 2018 -0600 ---------------------------------------------------------------------- .../org/apache/commons/lang3/RegExUtils.java | 290 +++++++++---------- 1 file changed, 145 insertions(+), 145 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/commons-lang/blob/bcc4f82a/src/main/java/org/apache/commons/lang3/RegExUtils.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/lang3/RegExUtils.java b/src/main/java/org/apache/commons/lang3/RegExUtils.java index 97c32fc..d148150 100644 --- a/src/main/java/org/apache/commons/lang3/RegExUtils.java +++ b/src/main/java/org/apache/commons/lang3/RegExUtils.java @@ -26,6 +26,42 @@ import java.util.regex.Pattern; public class RegExUtils { /** + * <p>Removes each substring of the text String that matches the given regular expression pattern.</p> + * + * This method is a {@code null} safe equivalent to: + * <ul> + * <li>{@code pattern.matcher(text).replaceAll(StringUtils.EMPTY)}</li> + * </ul> + * + * <p>A {@code null} reference passed to this method is a no-op.</p> + * + * <pre> + * 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" + * </pre> + * + * @param text text to remove from, may be null + * @param regex the regular expression to which this string is to be matched + * @return the text with any removes processed, + * {@code null} if null String input + * + * @see #replaceAll(String, Pattern, String) + * @see java.util.regex.Matcher#replaceAll(String) + * @see java.util.regex.Pattern + */ + public static String removeAll(final String text, final Pattern regex) { + return replaceAll(text, regex, StringUtils.EMPTY); + } + + /** * <p>Removes each substring of the text String that matches the given regular expression.</p> * * This method is a {@code null} safe equivalent to: @@ -72,39 +108,39 @@ public class RegExUtils { } /** - * <p>Removes each substring of the text String that matches the given regular expression pattern.</p> + * <p>Removes the first substring of the text string that matches the given regular expression pattern.</p> * * This method is a {@code null} safe equivalent to: * <ul> - * <li>{@code pattern.matcher(text).replaceAll(StringUtils.EMPTY)}</li> + * <li>{@code pattern.matcher(text).replaceFirst(StringUtils.EMPTY)}</li> * </ul> * * <p>A {@code null} reference passed to this method is a no-op.</p> * * <pre> - * 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" + * 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" * </pre> * * @param text text to remove from, may be null - * @param regex the regular expression to which this string is to be matched - * @return the text with any removes processed, + * @param regex the regular expression pattern to which this string is to be matched + * @return the text with the first replacement processed, * {@code null} if null String input * - * @see #replaceAll(String, Pattern, String) - * @see java.util.regex.Matcher#replaceAll(String) + * @see #replaceFirst(String, Pattern, String) + * @see java.util.regex.Matcher#replaceFirst(String) * @see java.util.regex.Pattern */ - public static String removeAll(final String text, final Pattern regex) { - return replaceAll(text, regex, StringUtils.EMPTY); + public static String removeFirst(final String text, final Pattern regex) { + return replaceFirst(text, regex, StringUtils.EMPTY); } /** @@ -153,114 +189,77 @@ public class RegExUtils { } /** - * <p>Removes the first substring of the text string that matches the given regular expression pattern.</p> - * - * This method is a {@code null} safe equivalent to: - * <ul> - * <li>{@code pattern.matcher(text).replaceFirst(StringUtils.EMPTY)}</li> - * </ul> - * - * <p>A {@code null} reference passed to this method is a no-op.</p> - * - * <pre> - * 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" - * </pre> - * - * @param text text to remove from, may be null - * @param regex the regular expression pattern to which this string is to be matched - * @return the text with the first replacement processed, - * {@code null} if null String input - * - * @see #replaceFirst(String, Pattern, String) - * @see java.util.regex.Matcher#replaceFirst(String) - * @see java.util.regex.Pattern - */ - public static String removeFirst(final String text, final Pattern regex) { - return replaceFirst(text, regex, StringUtils.EMPTY); - } - - /** - * <p>Replaces each substring of the source String that matches the given regular expression with the given - * replacement using the {@link Pattern#DOTALL} option. DOTALL is also known as single-line mode in Perl.</p> + * <p>Removes each substring of the source String that matches the given regular expression using the DOTALL option.</p> * * This call is a {@code null} safe equivalent to: * <ul> - * <li>{@code text.replaceAll("(?s)" + regex, replacement)}</li> - * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement)}</li> + * <li>{@code text.replaceAll("(?s)" + regex, StringUtils.EMPTY)}</li> + * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(StringUtils.EMPTY)}</li> * </ul> * * <p>A {@code null} reference passed to this method is a no-op.</p> * * <pre> - * 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" + * StringUtils.removePattern(null, *) = null + * StringUtils.removePattern("any", (String) null) = "any" + * StringUtils.removePattern("A<__>\n<__>B", "<.*>") = "AB" + * StringUtils.removePattern("ABCabc123", "[a-z]") = "ABC123" * </pre> * * @param text * the source string * @param regex * the regular expression to which this string is to be matched - * @param replacement - * the string to be substituted for each match * @return The resulting {@code String} - * @see #replaceAll(String, String, String) + * @see #replacePattern(String, String, String) * @see String#replaceAll(String, String) * @see Pattern#DOTALL */ - public static String replacePattern(final String text, final String regex, final String replacement) { - if (text == null || regex == null || replacement == null) { - return text; - } - return Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement); + public static String removePattern(final String text, final String regex) { + return replacePattern(text, regex, StringUtils.EMPTY); } /** - * <p>Removes each substring of the source String that matches the given regular expression using the DOTALL option.</p> + * <p>Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.</p> * - * This call is a {@code null} safe equivalent to: + * This method is a {@code null} safe equivalent to: * <ul> - * <li>{@code text.replaceAll("(?s)" + regex, StringUtils.EMPTY)}</li> - * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(StringUtils.EMPTY)}</li> + * <li>{@code pattern.matcher(text).replaceAll(replacement)}</li> * </ul> * * <p>A {@code null} reference passed to this method is a no-op.</p> * * <pre> - * StringUtils.removePattern(null, *) = null - * StringUtils.removePattern("any", (String) null) = "any" - * StringUtils.removePattern("A<__>\n<__>B", "<.*>") = "AB" - * StringUtils.removePattern("ABCabc123", "[a-z]") = "ABC123" + * 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" * </pre> * - * @param text - * the source string - * @param regex - * the regular expression to which this string is to be matched - * @return The resulting {@code String} - * @see #replacePattern(String, String, String) - * @see String#replaceAll(String, String) - * @see Pattern#DOTALL + * @param text text to search and replace in, may be null + * @param regex the regular expression pattern to which this string is to be matched + * @param replacement the string to be substituted for each match + * @return the text with any replacements processed, + * {@code null} if null String input + * + * @see java.util.regex.Matcher#replaceAll(String) + * @see java.util.regex.Pattern */ - public static String removePattern(final String text, final String regex) { - return replacePattern(text, regex, StringUtils.EMPTY); + public static String replaceAll(final String text, final Pattern regex, final String replacement) { + if (text == null || regex == null || replacement == null) { + return text; + } + return regex.matcher(text).replaceAll(replacement); } /** @@ -318,46 +317,46 @@ public class RegExUtils { } /** - * <p>Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.</p> + * <p>Replaces the first substring of the text string that matches the given regular expression pattern + * with the given replacement.</p> * * This method is a {@code null} safe equivalent to: * <ul> - * <li>{@code pattern.matcher(text).replaceAll(replacement)}</li> + * <li>{@code pattern.matcher(text).replaceFirst(replacement)}</li> * </ul> * * <p>A {@code null} reference passed to this method is a no-op.</p> * * <pre> - * 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" + * 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" * </pre> * * @param text text to search and replace in, may be null * @param regex the regular expression pattern to which this string is to be matched - * @param replacement the string to be substituted for each match - * @return the text with any replacements processed, + * @param replacement the string to be substituted for the first match + * @return the text with the first replacement processed, * {@code null} if null String input * - * @see java.util.regex.Matcher#replaceAll(String) + * @see java.util.regex.Matcher#replaceFirst(String) * @see java.util.regex.Pattern */ - public static String replaceAll(final String text, final Pattern regex, final String replacement) { - if (text == null || regex == null || replacement == null) { + public static String replaceFirst(final String text, final Pattern regex, final String replacement) { + if (text == null || regex == null|| replacement == null ) { return text; } - return regex.matcher(text).replaceAll(replacement); + return regex.matcher(text).replaceFirst(replacement); } /** @@ -413,46 +412,47 @@ public class RegExUtils { } /** - * <p>Replaces the first substring of the text string that matches the given regular expression pattern - * with the given replacement.</p> + * <p>Replaces each substring of the source String that matches the given regular expression with the given + * replacement using the {@link Pattern#DOTALL} option. DOTALL is also known as single-line mode in Perl.</p> * - * This method is a {@code null} safe equivalent to: + * This call is a {@code null} safe equivalent to: * <ul> - * <li>{@code pattern.matcher(text).replaceFirst(replacement)}</li> + * <li>{@code text.replaceAll("(?s)" + regex, replacement)}</li> + * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement)}</li> * </ul> * * <p>A {@code null} reference passed to this method is a no-op.</p> * * <pre> - * 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" + * 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" * </pre> * - * @param text text to search and replace in, may be null - * @param regex the regular expression pattern to which this string is to be matched - * @param replacement the string to be substituted for the first match - * @return the text with the first replacement processed, - * {@code null} if null String input - * - * @see java.util.regex.Matcher#replaceFirst(String) - * @see java.util.regex.Pattern + * @param text + * the source string + * @param regex + * the regular expression to which this string is to be matched + * @param replacement + * the string to be substituted for each match + * @return The resulting {@code String} + * @see #replaceAll(String, String, String) + * @see String#replaceAll(String, String) + * @see Pattern#DOTALL */ - public static String replaceFirst(final String text, final Pattern regex, final String replacement) { - if (text == null || regex == null|| replacement == null ) { + public static String replacePattern(final String text, final String regex, final String replacement) { + if (text == null || regex == null || replacement == null) { return text; } - return regex.matcher(text).replaceFirst(replacement); + return Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement); } }
