Question

下面定义了2个功能。它们执行完全相同的功能，即输入模板（其中一个想要替换一些子串）和字符串值数组（要替换的键值对，ex：[subStrToReplace1，value1，subStrToReplace1，value2，.....] ）并返回替换的String。

在第二个函数中，我迭代模板的单词并搜索相关的键（如果存在于hashmap中，然后是下一个单词）。如果我想用一些子字符串替换一个单词，我再次想要用值中的其他键替换，我需要迭代模板两次。多数民众赞成我所做的。

我想知道我应该使用哪一个以及为什么？除了这些之外的任何其他选择也是受欢迎的。

第一个功能

public static String populateTemplate1(String template, String... values) {
    String populatedTemplate = template;
    for (int i = 0; i < values.length; i += 2) {
        populatedTemplate = populatedTemplate.replace(values[i], values[i + 1]);
    }
    return populatedTemplate;
}

第二功能

public static String populateTemplate2(String template, String... values) {
    HashMap<String, String> map = new HashMap<>();
    for (int i = 0; i < values.length; i += 2) {
        map.put(values[i],values[i+1]);
    }
    StringBuilder regex = new StringBuilder();
    boolean first = true;
    for (String word : map.keySet()) {
        if (first) {
            first = false;
        } else {
            regex.append('|');
        }
        regex.append(Pattern.quote(word));
    }
    Pattern pattern = Pattern.compile(regex.toString());

    int N0OfIterationOverTemplate =2;
    // Pattern allowing to extract only the words
    // Pattern pattern = Pattern.compile("\\w+");
    StringBuilder populatedTemplate=new StringBuilder();;

    String temp_template=template;

    while(N0OfIterationOverTemplate!=0){
        populatedTemplate = new StringBuilder();
        Matcher matcher = pattern.matcher(temp_template);
        int fromIndex = 0;
        while (matcher.find(fromIndex)) {
            // The start index of the current word
            int startIdx = matcher.start();
            if (fromIndex < startIdx) {
                // Add what we have between two words
                populatedTemplate.append(temp_template, fromIndex, startIdx);
            }
            // The current word
            String word = matcher.group();
            // Replace the word by itself or what we have in the map
            // populatedTemplate.append(map.getOrDefault(word, word));

            if (map.get(word) == null) {
                populatedTemplate.append(word);
            }
            else {
                populatedTemplate.append(map.get(word));
            }

            // Start the next find from the end index of the current word
            fromIndex = matcher.end();
        }
        if (fromIndex < temp_template.length()) {
            // Add the remaining sub String
            populatedTemplate.append(temp_template, fromIndex, temp_template.length());
        }

        N0OfIterationOverTemplate--;
        temp_template=populatedTemplate.toString();
    }
    return populatedTemplate.toString();
}

Answer 1

至少有两个原因明确是第一个：

它更易于阅读和更短，因此更容易维护，因为它更不容易出错
你不依赖正则表达式，所以到目前为止它更快

Answer 2

第一个功能更清晰，更容易理解。除非您（通过分析器）发现它需要相当长的时间并且减慢您的应用程序速度，否则我会更喜欢它。然后你就可以弄清楚如何优化它。

Answer 3

为什么在简单易行时会让事情变得复杂。

请记住，简单的解决方案往往是最好的。

仅供参考，如果元素数为奇数，则会得到一个ArrayIndexOutOfBoundsException。

我建议改进这个：

public static String populateTemplate(String template, String... values) {
        String populatedTemplate = template;
        int nextTarget = 2;
        int lastTarget = values.length - nextTarget;

        for (int i = 0; i <= lastTarget; i += nextTarget) {
            String target = values[i];
            String replacement = values[i + 1];
            populatedTemplate = populatedTemplate.replace(target, replacement);
        }
        return populatedTemplate;
    }

“优秀的程序员编写人类可以理解的代码”。马丁福勒

替换字符串中的多个子字符串，Array vs HashMap

3 个答案: