java中的字符串更换多个不同的子一次（或以最有效的方式）(Java Replacing multi

我需要更换许多不同的子串在字符串中的最有效的方式。 有那么其他另一种方式代替使用与string.replace每个字段的蛮力方法是什么？

Answer 1:

如果您在操作字符串很长，或者您在操作上许多字符串，那么它可能是值得使用java.util.regex.Matcher中（这需要时间的前期进行编译，所以它不会是有效的如果你的输入是非常小或您的搜索模式勤换）。

下面是一个完整的例子，基于从地图取令牌的名单上。 （Apache的Commons Lang中使用StringUtils的）。

Map<String,String> tokens = new HashMap<String,String>();
tokens.put("cat", "Garfield");
tokens.put("beverage", "coffee");

String template = "%cat% really needs some %beverage%.";

// Create pattern of the format "%(cat|beverage)%"
String patternString = "%(" + StringUtils.join(tokens.keySet(), "|") + ")%";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(template);

StringBuffer sb = new StringBuffer();
while(matcher.find()) {
    matcher.appendReplacement(sb, tokens.get(matcher.group(1)));
}
matcher.appendTail(sb);

System.out.println(sb.toString());

一旦正则表达式编译，扫描输入字符串一般是很快的（虽然如果你的正则表达式是复杂或涉及回溯，那么你仍然需要在基准为了证实这一点！）

Answer 2:

算法

其中最有效的方式来代替匹配的字符串（无正则表达式）是使用阿霍Corasick算法与高性能的特里 （发音为“试”），快速散列算法，高效的集合实现。

简单代码

一个简单的解决方案充分利用Apache的StringUtils.replaceEach如下：

  private String testStringUtils(
    final String text, final Map<String, String> definitions ) {
    final String[] keys = keys( definitions );
    final String[] values = values( definitions );

    return StringUtils.replaceEach( text, keys, values );
  }

这大大降低了大文章。

快速的代码

博尔的实现的阿霍Corasick算法的引入了一点复杂性，通过使用具有同样的方法签名的外观成为一个实现细节：

  private String testBorAhoCorasick(
    final String text, final Map<String, String> definitions ) {
    // Create a buffer sufficiently large that re-allocations are minimized.
    final StringBuilder sb = new StringBuilder( text.length() << 1 );

    final TrieBuilder builder = Trie.builder();
    builder.onlyWholeWords();
    builder.removeOverlaps();

    final String[] keys = keys( definitions );

    for( final String key : keys ) {
      builder.addKeyword( key );
    }

    final Trie trie = builder.build();
    final Collection<Emit> emits = trie.parseText( text );

    int prevIndex = 0;

    for( final Emit emit : emits ) {
      final int matchIndex = emit.getStart();

      sb.append( text.substring( prevIndex, matchIndex ) );
      sb.append( definitions.get( emit.getKeyword() ) );
      prevIndex = emit.getEnd() + 1;
    }

    // Add the remainder of the string (contains no more matches).
    sb.append( text.substring( prevIndex ) );

    return sb.toString();
  }

基准

为基准，将缓冲液使用创建randomNumeric如下：

  private final static int TEXT_SIZE = 1000;
  private final static int MATCHES_DIVISOR = 10;

  private final static StringBuilder SOURCE
    = new StringBuilder( randomNumeric( TEXT_SIZE ) );

凡MATCHES_DIVISOR决定的变量注入数：

  private void injectVariables( final Map<String, String> definitions ) {
    for( int i = (SOURCE.length() / MATCHES_DIVISOR) + 1; i > 0; i-- ) {
      final int r = current().nextInt( 1, SOURCE.length() );
      SOURCE.insert( r, randomKey( definitions ) );
    }
  }

基准代码本身（ 江铃控股似乎矫枉过正）：

long duration = System.nanoTime();
final String result = testBorAhoCorasick( text, definitions );
duration = System.nanoTime() - duration;
System.out.println( elapsed( duration ) );

1000000：1000

一个简单的微基准测试以百万字符和1000随机放置字符串替换。

• testStringUtils：25秒，25533个米利斯
• testBorAhoCorasick：0秒，68毫秒时间

没有比赛。

10000：1000

使用10,000个字符和1,000匹配的字符串替换：

• testStringUtils 1秒，1402个米利斯
• testBorAhoCorasick：0秒，37毫秒时间

除法关闭。

1000：10

使用1000个字符和10名匹配的字符串替换：

• testStringUtils：0秒，7个米利斯
• testBorAhoCorasick：0秒，19毫秒时间

对于短字符串，建立阿霍Corasick的开销月食由蛮力方法StringUtils.replaceEach 。

基于文字长度的混合方法是可能的，以获得最佳的两个实现的。

实现

考虑文本超过1 MB比较其他实现更长的时间，其中包括：

• https://github.com/RokLenarcic/AhoCorasick
• https://github.com/hankcs/AhoCorasickDoubleArrayTrie
• https://github.com/raymanrt/aho-corasick
• https://github.com/ssundaresan/Aho-Corasick
• https://github.com/jmhsieh/aho-corasick
• https://github.com/quest-oss/Mensa

文件

论文和相关信息的算法：

• http://www.cs.uku.fi/research/publications/reports/A-2005-2.pdf
• https://pdfs.semanticscholar.org/3547/ac839d02f6efe3f6f76a8289738a22528442.pdf
• http://www.ece.ncsu.edu/asic/ece792A/2009/ECE792A/Readings_files/00989753.pdf
• http://blog.ivank.net/aho-corasick-algorithm-in-as3.html

Answer 3:

如果你将要改变一个字符串很多次，那么它通常是更有效地使用StringBuilder（但衡量你的表现，找出）：

String str = "The rain in Spain falls mainly on the plain";
StringBuilder sb = new StringBuilder(str);
// do your replacing in sb - although you'll find this trickier than simply using String
String newStr = sb.toString();

每次你做一个替换字符串，创建一个新的String对象，因为字符串是不可改变的。 StringBuilder的是可变的，也就是说，它是可以改变的，只要你想尽可能多。

Answer 4:

StringBuilder将执行更换更有效，因为它的字符数组缓冲器可以被指定到一所需的长度。 StringBuilder是专为不是追加更多！

当然，真正的问题是，这是否是一种优化太远？ JVM是在处理多个对象的创建和随后的垃圾收集非常好，而且像所有的优化问题，我的第一个问题是你是否已经测量这一点，并确定这是一个问题。

Answer 5:

这为我工作：

String result = input.replaceAll("string1|string2|string3","replacementString");

例：

String input = "applemangobananaarefriuits";
String result = input.replaceAll("mango|are|ts","-");
System.out.println(result);

输出：苹果香蕉friui-

Answer 6:

如何使用的replaceAll（）方法？

Answer 7:

节奏java的模板引擎已经发布带有所谓的新功能路线插值模式 ，它允许你做这样的事情：

String result = Rythm.render("@name is inviting you", "Diana");

上述案例表明您可以通过位置传递参数模板。 节奏还允许您通过名字来传递参数：

Map<String, Object> args = new HashMap<String, Object>();
args.put("title", "Mr.");
args.put("name", "John");
String result = Rythm.render("Hello @title @name", args);

注意节奏非常快，比的String.format和速度约快2至3倍，因为它编译模板到Java字节码，运行时性能非常接近与StringBuilder的到concatentation。

链接：

• 检查全功能演示
• 阅读简要介绍了节奏
• 下载最新的包或
• 它叉

Answer 8:

检查：

的String.format（STR，STR []）

...

例如：

的String.format（ “把你的％S在您％s是”， “金钱”， “嘴”）;

Answer 9:

以下是根据托德·欧文的回答 。 该解决方案有，如果替换包含在正则表达式特殊含义的字符，你可以得到意想不到的效果的问题。 我也希望能够有选择地做一个区分大小写的搜索。 以下是我想出了：

/**
 * Performs simultaneous search/replace of multiple strings. Case Sensitive!
 */
public String replaceMultiple(String target, Map<String, String> replacements) {
  return replaceMultiple(target, replacements, true);
}

/**
 * Performs simultaneous search/replace of multiple strings.
 * 
 * @param target        string to perform replacements on.
 * @param replacements  map where key represents value to search for, and value represents replacem
 * @param caseSensitive whether or not the search is case-sensitive.
 * @return replaced string
 */
public String replaceMultiple(String target, Map<String, String> replacements, boolean caseSensitive) {
  if(target == null || "".equals(target) || replacements == null || replacements.size() == 0)
    return target;

  //if we are doing case-insensitive replacements, we need to make the map case-insensitive--make a new map with all-lower-case keys
  if(!caseSensitive) {
    Map<String, String> altReplacements = new HashMap<String, String>(replacements.size());
    for(String key : replacements.keySet())
      altReplacements.put(key.toLowerCase(), replacements.get(key));

    replacements = altReplacements;
  }

  StringBuilder patternString = new StringBuilder();
  if(!caseSensitive)
    patternString.append("(?i)");

  patternString.append('(');
  boolean first = true;
  for(String key : replacements.keySet()) {
    if(first)
      first = false;
    else
      patternString.append('|');

    patternString.append(Pattern.quote(key));
  }
  patternString.append(')');

  Pattern pattern = Pattern.compile(patternString.toString());
  Matcher matcher = pattern.matcher(target);

  StringBuffer res = new StringBuffer();
  while(matcher.find()) {
    String match = matcher.group(1);
    if(!caseSensitive)
      match = match.toLowerCase();
    matcher.appendReplacement(res, replacements.get(match));
  }
  matcher.appendTail(res);

  return res.toString();
}

这里是我的单元测试用例：

@Test
public void replaceMultipleTest() {
  assertNull(ExtStringUtils.replaceMultiple(null, null));
  assertNull(ExtStringUtils.replaceMultiple(null, Collections.<String, String>emptyMap()));
  assertEquals("", ExtStringUtils.replaceMultiple("", null));
  assertEquals("", ExtStringUtils.replaceMultiple("", Collections.<String, String>emptyMap()));

  assertEquals("folks, we are not sane anymore. with me, i promise you, we will burn in flames", ExtStringUtils.replaceMultiple("folks, we are not winning anymore. with me, i promise you, we will win big league", makeMap("win big league", "burn in flames", "winning", "sane")));

  assertEquals("bcaacbbcaacb", ExtStringUtils.replaceMultiple("abccbaabccba", makeMap("a", "b", "b", "c", "c", "a")));
  assertEquals("bcaCBAbcCCBb", ExtStringUtils.replaceMultiple("abcCBAabCCBa", makeMap("a", "b", "b", "c", "c", "a")));
  assertEquals("bcaacbbcaacb", ExtStringUtils.replaceMultiple("abcCBAabCCBa", makeMap("a", "b", "b", "c", "c", "a"), false));

  assertEquals("c colon  backslash temp backslash  star  dot  star ", ExtStringUtils.replaceMultiple("c:\\temp\\*.*", makeMap(".", " dot ", ":", " colon ", "\\", " backslash ", "*", " star "), false));
}

private Map<String, String> makeMap(String ... vals) {
  Map<String, String> map = new HashMap<String, String>(vals.length / 2);
  for(int i = 1; i < vals.length; i+= 2)
    map.put(vals[i-1], vals[i]);
  return map;
}

Answer 10:

public String replace(String input, Map<String, String> pairs) {
  // Reverse lexic-order of keys is good enough for most cases,
  // as it puts longer words before their prefixes ("tool" before "too").
  // However, there are corner cases, which this algorithm doesn't handle
  // no matter what order of keys you choose, eg. it fails to match "edit"
  // before "bed" in "..bedit.." because "bed" appears first in the input,
  // but "edit" may be the desired longer match. Depends which you prefer.
  final Map<String, String> sorted = 
      new TreeMap<String, String>(Collections.reverseOrder());
  sorted.putAll(pairs);
  final String[] keys = sorted.keySet().toArray(new String[sorted.size()]);
  final String[] vals = sorted.values().toArray(new String[sorted.size()]);
  final int lo = 0, hi = input.length();
  final StringBuilder result = new StringBuilder();
  int s = lo;
  for (int i = s; i < hi; i++) {
    for (int p = 0; p < keys.length; p++) {
      if (input.regionMatches(i, keys[p], 0, keys[p].length())) {
        /* TODO: check for "edit", if this is "bed" in "..bedit.." case,
         * i.e. look ahead for all prioritized/longer keys starting within
         * the current match region; iff found, then ignore match ("bed")
         * and continue search (find "edit" later), else handle match. */
        // if (better-match-overlaps-right-ahead)
        //   continue;
        result.append(input, s, i).append(vals[p]);
        i += keys[p].length();
        s = i--;
      }
    }
  }
  if (s == lo) // no matches? no changes!
    return input;
  return result.append(input, s, hi).toString();
}

文章来源: Java Replacing multiple different substring in a string at once (or in the most efficient way)