在java中如何用相应的字符替换特定字符？

我想这样做：用

k

替换所有

ck

，用

wr

替换所有

dd

，用

m

替换所有

f

，再替换10次。 我可以用

replace（“ck”，“k”）。replace（“dd”，“wr”）

等等来做，但它很傻，速度也很慢。java中有这样的函数吗？ 例如

replace（字符串、stringArray1、stringArray2）
使用循环

以下是一种通用方法：

private static String replace(String input, Map<String, String> mappings) {
    StringBuffer buf = new StringBuffer();
    Matcher m = Pattern.compile(toRegex(mappings.keySet())).matcher(input);
    while (m.find())
        m.appendReplacement(buf, Matcher.quoteReplacement(mappings.get(m.group())));
    return m.appendTail(buf).toString();
}
private static String toRegex(Collection<String> keys) {
    return keys.stream().map(Pattern::quote).collect(Collectors.joining("|"));
}

私有静态字符串替换（字符串输入、映射映射）{
StringBuffer buf=新的StringBuffer（）；
Matcher m=Pattern.compile（toRegex（mappings.keySet（））.Matcher（input）；
while（m.find（））
m、 appendReplacement（buf，Matcher.quoteReplacement（mappings.get（m.group（）））；
返回m.appendTail（buf.toString（）；
}
私有静态字符串toRegex（集合密钥）{
return keys.stream（）.map（Pattern:：quote）.collect（collector.joining（“|”）；
}

如果您没有使用Java 8+，第二种方法是：

private static String toRegex(Collection<String> keys) {
    StringBuilder regex = new StringBuilder();
    for (String key : keys) {
        if (regex.length() != 0)
            regex.append("|");
        regex.append(Pattern.quote(key));
    }
    return regex.toString();
}

私有静态字符串toRegex（集合密钥）{
StringBuilder正则表达式=新的StringBuilder（）；
用于（字符串键：键）{
if（regex.length（）！=0）
regex.append（“|”）；
regex.append（Pattern.quote（key））；
}
返回regex.toString（）；
}

测试代码

Map mappings=newhashmap（）；
映射。put（“ck”，“k”）；
映射。put（“dd”、“wr”）；
映射。put（“f”、“m”）；
System.out.println（替换（“奇群”，映射））；//打印：owr mlok

有关运行版本，请参阅。
Map replacementMap=newhashmap（）；
Map<String, String> replacementMap = new HashMap<String, String>();
replacementMap.put("ck", "k");
replacementMap.put("dd", "wr");
replacementMap.put("f", "m");
// ...

String resultStr = "Abck fdddk wr fmck"; // whatever string to process
StringBuilder builder = new StringBuilder(resultStr); // wrap it in builder

Iterator<String> iterator = replacementMap.keySet().iterator();
while (iterator.hasNext()) {
    String strToReplace = iterator.next();
    replaceAll(builder, strToReplace, replacementMap.get(strToReplace));
}
System.out.println("Result is: " + builder.toString());

public static void replaceAll(StringBuilder builder, String from, String to) {
    int index = builder.indexOf(from);
    while (index != -1) {
        builder.replace(index, index + from.length(), to);
        index += to.length(); // Move to the end of the replacement
        index = builder.indexOf(from, index);
    }
}

替换图。放置（“ck”、“k”）；
替换地图放置（“dd”、“wr”）；
替换图。放置（“f”、“m”）；
// ...
字符串结果tr=“Abck fdddk wr fmck”//不管要处理的字符串是什么
StringBuilder=新的StringBuilder（resultStr）；//用生成器包装它
迭代器迭代器=replacementMap.keySet（）.Iterator（）；
while（iterator.hasNext（））{
字符串strToReplace=iterator.next（）；
replaceAll（builder、strToReplace、replacementMap.get（strToReplace））；
}
System.out.println（“结果是：+builder.toString（））；
公共静态void replaceAll（StringBuilder生成器、字符串从、字符串到）{
int index=builder.indexOf（from）；
while（索引！=-1）{
替换（索引，索引+from.length（），到）；
index+=to.length（）；//移动到替换的末尾
index=builder.indexOf（from，index）；
}
}

replaceAll（）方法是从中借用的

这个例子是使用ApacheCommons库，有一个类提供了replaceAll（）方法。请参见
这种方法有什么问题？我认为这比你的建议更容易阅读。这是另一种选择：@JoeC可能，但它将迭代字符串的次数与替换规则的次数相同。Ok new try:）我不确定这一点，但这里有另一个可能很有趣的答案：……或者这类似于你的建议
Map<String, String> replacementMap = new HashMap<String, String>();
replacementMap.put("ck", "k");
replacementMap.put("dd", "wr");
replacementMap.put("f", "m");
// ...

String resultStr = "Abck fdddk wr fmck"; // whatever string to process
StringBuilder builder = new StringBuilder(resultStr); // wrap it in builder

Iterator<String> iterator = replacementMap.keySet().iterator();
while (iterator.hasNext()) {
    String strToReplace = iterator.next();
    replaceAll(builder, strToReplace, replacementMap.get(strToReplace));
}
System.out.println("Result is: " + builder.toString());

public static void replaceAll(StringBuilder builder, String from, String to) {
    int index = builder.indexOf(from);
    while (index != -1) {
        builder.replace(index, index + from.length(), to);
        index += to.length(); // Move to the end of the replacement
        index = builder.indexOf(from, index);
    }
}