Question

我有一个String，想要替换其中的一些单词。我有一个HashMap，其中键是要替换的占位符，以及要替换它的单词的值。这是我的老派代码：

  private String replace(String text, Map<String, String> map) {
    for (Entry<String, String> entry : map.entrySet()) {
      text = text.replaceAll(entry.getKey(), entry.getValue());
    }
    return text;
  }

有没有办法将此代码编写为lambda表达式？

我尝试entrySet().stream().map(...).reduce(...).apply(...);但无法使其正常工作。

提前致谢。

Answer 1

我认为您不应该尝试寻找更简单或更简短的解决方案，而应考虑您的方法的语义和效率。

您正在迭代可能没有指定迭代顺序的地图（如HashMap）并执行一个接一个的替换，使用替换的结果作为输入到下一个可能缺少的匹配，因为之前已应用替换或替换替换内容。

即使我们假设您正在传递其键和值没有干扰的地图，这种方法效率非常低。另请注意，replaceAll会将参数解释为正则表达式。

如果我们假设没有正则表达式，我们可以通过按长度排序来清除密钥之间的歧义，以便首先尝试更长的密钥。然后，执行单个替换操作的解决方案可能如下所示：

private static String replace(String text, Map<String, String> map) {
    if(map.isEmpty()) return text;
    String pattern = map.keySet().stream()
        .sorted(Comparator.comparingInt(String::length).reversed())
        .map(Pattern::quote)
        .collect(Collectors.joining("|"));
    Matcher m = Pattern.compile(pattern).matcher(text);
    if(!m.find()) return text;
    StringBuffer sb = new StringBuffer();
    do m.appendReplacement(sb, Matcher.quoteReplacement(map.get(m.group())));
       while(m.find());
    return m.appendTail(sb).toString();
}

^{从Java 9开始，您可以在此使用StringBuilder代替StringBuffer}

如果您使用

进行测试

Map<String, String> map = new HashMap<>();
map.put("f", "F");
map.put("foo", "bar");
map.put("b", "B");
System.out.println(replace("foo, bar, baz", map));

你会得到

bar, Bar, Baz

证明替换foo优先于替换f，并且替换b中的bar不会被替换。

如果您希望再次替换替换中的匹配，那么另一件事就是。在这种情况下，您需要一种机制来控制订单或实现重复替换，只有在没有匹配时才会返回。当然，后者需要注意提供最终会收敛到结果的替代品。

E.g。

private static String replaceRepeatedly(String text, Map<String, String> map) {
    if(map.isEmpty()) return text;
    String pattern = map.keySet().stream()
        .sorted(Comparator.comparingInt(String::length).reversed())
        .map(Pattern::quote)
        .collect(Collectors.joining("|"));
    Matcher m = Pattern.compile(pattern).matcher(text);
    if(!m.find()) return text;
    StringBuffer sb;
    do {
        sb = new StringBuffer();
        do m.appendReplacement(sb, Matcher.quoteReplacement(map.get(m.group())));
           while(m.find());
        m.appendTail(sb);
    } while(m.reset(sb).find());
    return sb.toString();
}

Map<String, String> map = new HashMap<>();
map.put("a", "e1");
map.put("e", "o2");
map.put("o", "x3");
System.out.println(replaceRepeatedly("foo, bar, baz", map));

fx3x3, bx321r, bx321z

Answer 2

您可以使用以下每个循环：

  private String replace(String text, Map<String, String> map) {
      final StringBuilder sb = new StringBuilder(text);
      map.forEach((k,v)->replaceAll(sb, k, v));
      return sb.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);
    }
}

如果您使用多线程，也可以使用StringBuffer。

Answer 3

@RavindraRanwala的代码很少有改进。

    String replacement = Stream.of(text.split("\\b"))
            .map(token -> map.getOrDefault(token, token))
            .collect(Collectors.joining(""));

1）使用Java 8中的Map.getOrDefault

2）用“\ b”分隔以支持单词的任何分隔符，而不仅仅是空格字符

Answer 4

这是更强大的解决方案，假设每个单词由空格字符分隔，

String replacement = Stream.of(source.split(" ")).map(token -> map.get(token) != null ? map.get(token) : token)
        .collect(Collectors.joining(" "));

Answer 5

出于实际目的，您的非流代码就可以了。作为一项有趣的练习，您可以将每个映射表示为Function<String,String>并减少函数：

Function<String,String> combined = map.entrySet().stream()
        .reduce(
                Function.identity(),
                (f, e) -> x -> f.apply(x).replaceAll(e.getKey(), e.getValue()),
                Function::andThen
        );

return combined.apply(text);

Java 8将HashMap上的Map减少为lambda

5 个答案: