java - 使用递归替换字符串序列

Question

很难说出这里问的是什么。这个问题是含糊的、模糊的、不完整的、过于宽泛的或修辞性的，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开它， visit the help center 。

已关闭 10 年前。

Java 具有replace() 和replaceAll() 方法，可以用给定的新模式替换字符串的部分/序列。该函数的内部是如何工作的？如果我必须编写一个函数来输入字符串、OldPattern、NewPattern，并在不使用 RegEx 的情况下递归地用 NewPattern 替换所有出现的 OldPattern，该怎么办？我已经使用字符串输入的迭代完成了以下代码，它似乎有效。如果输入是字符数组而不是字符串怎么办？

  public String replaceOld(String aInput, String aOldPattern, String aNewPattern)
        {
             if ( aOldPattern.equals("") ) {
                throw new IllegalArgumentException("Old pattern must have content.");
             }

             final StringBuffer result = new StringBuffer();
             int startIdx = 0;
             int idxOld = 0;
             while ((idxOld = aInput.indexOf(aOldPattern, startIdx)) >= 0) {
               result.append( aInput.substring(startIdx, idxOld) );
               result.append( aNewPattern );

               //reset the startIdx to just after the current match, to see
               //if there are any further matches
               startIdx = idxOld + aOldPattern.length();
             }
             //the final chunk will go to the end of aInput
             result.append( aInput.substring(startIdx) );
             return result.toString();
          }

Answer 1

Java has the replace() and replaceAll() methods to replace parts/sequence of a string with a given new pattern.

准确地说，这些方法创建新字符串并替换相关字符。 Java 字符串是不可变的。

How does the internal of that function work?

这太复杂了，无法在这里详细解释。 (实际上，具体细节可能因不同的实现而异)。最好的选择是自己阅读相关库类的源代码。 (源代码作为 JDK 的一部分分发，您的 Java IDE 应该能够向您显示它。或者，Google 搜索会在网络上为您找到它。)

What if I had to write a function that inputs a string, OldPattern, NewPattern and replaces every occurrence of OldPattern with the NewPattern recursively without using RegEx?

好吧，如果您正在谈论在不使用 Pattern 类的情况下进行模式匹配/替换，那么是的，会很棘手......更不用说它会是无意义。

(递归解决方案可能很危险。考虑这个问题:“递归地用“a”中的“ba”替换“a”的所有实例。结果应该是什么？您是否应该尝试这样做？)

<小时/>

假设参数是简单的字符串(不是您描述的模式)，那么这是一个递归解决方案(未经测试):

public String replace1(String in, String target, String replacement) {
    if (target.isEmpty()) {
        return in;
    }
    int pos = in.indexOf(target);
    if (pos < 0) {
        return in;
    }
    String updated = in.substring(0, pos) + replacement + 
                     in.substring(pos + target.length());
    return replace1(updated, target, replacement);
}

这解决了¹您希望递归替换的问题版本；即您想要替换由替换过程插入的 target 实例的位置。如果您不想这样做，那么:

public String replace2(String in, String target, String replacement) {
    if (target.isEmpty()) {
        return in;
    }
    int pos = in.indexOf(target);
    if (pos < 0) {
        return in;
    }
    return in.substring(0, pos) + replacement + 
                     replace2(in.substring(pos + target.length()),
                             target, replacement);
}

请注意，这些解决方案的效率很可能低于原始迭代解决方案。甚至忽略正在发生的所有字符串复制。 Java 不进行尾部调用优化。

<小时/>

^{1 - 如果您使用病态参数调用 replace1，则会出现堆栈溢出。例如replace1("ab", "b", "b")}