使用递归替换字符串序列[关闭]

Question

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

  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 有 replace() 和 replaceAll() 方法可以用给定的新模式替换字符串的部分/序列。

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

该函数的内部是如何工作的？

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

如果我必须编写一个函数来输入字符串、OldPattern、NewPattern 并在不使用 RegEx 的情况下递归地用 NewPattern 替换每个出现的 OldPattern 怎么办？

好吧，如果您在谈论不使用 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")}

Answer 2

试试

public static String replaceOld(String aInput, String aOldPattern, String aNewPattern, int i) {
    i = aInput.indexOf(aOldPattern, i);
    if (i == -1) {
        return aInput;
    }
    aInput = aInput.substring(0, i) + aNewPattern + aInput.substring(i + aOldPattern.length());
    return replaceOld(aInput, aOldPattern, aNewPattern, i + aNewPattern.length());
}

注意参数i是用来优化的，所以indexOf不会每次都从pos 0开始扫描。并且它还解决了“a”问题中“递归地用“ba”替换所有“a”实例。

Answer 3

也许这种方法会回答你的问题。

  static int indexOf(char[] string, char[] pattern, int startIndex) {
     int index = startIndex;
     while(true) {
         while(index < string.length && string[index] != pattern[0]) index++;
         if(index >= string.length || index+pattern.length > string.length) return -1;
         boolean match = true;
         for(int i = 1; i < pattern.length; i++) {
             if(string[index+i] != pattern[i]) {
                 match = false;
                 break;
             }
         }
         if(match) return index;
         else index += 1;
     }
  }

如果你想要一个递归替换方法，使用这个

static String replace(String string, String pattern, String replacement) {
  int index = string.indexOf(pattern);
  if(index < 0) return string;
  int endIndex = index+pattern.length();
  return string.substring(0, index) + replacement +
      replace(string.substring(endIndex), pattern, replacement);
}