java - 字符串替换方法是否使用正则表达式？

Question

直到现在，我认为replace方法不使用正则表达式；还在String 内部查看类，我看到有一个模式编译就像在 replaceAll 中一样

我看到的唯一区别是 compile方法有一个标志 LITERAL放。

public String replace(CharSequence target, CharSequence replacement) {
        return Pattern.compile(target.toString(), Pattern.LITERAL)
                       .matcher(this)
                       .replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

所以我的问题是:

如果我正在使用 replace 进行密集的字符串替换(例如，数千个) for 循环中的方法，我应该缓存模式并使用它的匹配器来替换吗？

目前我使用

private static final Pattern patternContainsC = Pattern.compile("(~C)|(\\[C])");

加速一些使用 replaceAll 的循环方法来自 String类(class)。

Answer 1

String.replace(CharSequence target, CharSequence replacement)在旧版 JDK 中确实使用正则表达式:

JDK 7, lines 2213..2230

JDK 8, lines 2213..2228

从 Java 9 开始，String.replace不编译 target转换成正则表达式:

JDK 9: lines 2166..2200

JDK 11: lines 2129..2163 :

   /**
     * Replaces each substring of this string that matches the literal target
     * sequence with the specified literal replacement sequence. The
     * replacement proceeds from the beginning of the string to the end, for
     * example, replacing "aa" with "b" in the string "aaa" will result in
     * "ba" rather than "ab".
     *
     * @param  target The sequence of char values to be replaced
     * @param  replacement The replacement sequence of char values
     * @return  The resulting string
     * @since 1.5
     */
    public String replace(CharSequence target, CharSequence replacement) {
        String tgtStr = target.toString();
        String replStr = replacement.toString();
        int j = indexOf(tgtStr);
        if (j < 0) {
            return this;
        }
        int tgtLen = tgtStr.length();
        int tgtLen1 = Math.max(tgtLen, 1);
        int thisLen = length();

        int newLenHint = thisLen - tgtLen + replStr.length();
        if (newLenHint < 0) {
            throw new OutOfMemoryError();
        }
        StringBuilder sb = new StringBuilder(newLenHint);
        int i = 0;
        do {
            sb.append(this, i, j).append(replStr);
            i = j + tgtLen;
        } while (j < thisLen && (j = indexOf(tgtStr, j + tgtLen1)) > 0);
        return sb.append(this, i, thisLen).toString();
    }

方法String.replaceAll从目标编译自己的模式。

那么，如果同一个字符串模式应用于多个字符串，缓存模式并使用 Matcher 是合理的。的 replaceAll方法。

// this pattern checks if string contains '~C' or '[C]'
private static final Pattern patternContainsC = Pattern.compile("(~C)|(\\[C])");

public static String replaceSpecialC(String src, String replacement) {
    if (null == src || src.isEmpty()) {
        return src;
    }
    return patternContainsC.matcher(src).replaceAll(replacement);
}