Мне нужно заменить много разных подстрок в строке наиболее эффективным способом. есть ли другой способ, кроме того, грубая сила для замены каждого поля с помощью string.replace?
Java Замена нескольких разных подстрок в строке сразу (или наиболее эффективным способом)
Ответ 1
Если строка, в которой вы работаете, очень длинная, или вы работаете со многими строками, тогда это может быть полезно с помощью java.util.regex.Matcher(для этого требуется время для компиляции, t эффективны, если ваш вход очень мал или ваш шаблон поиска изменяется часто).
Ниже приведен полный пример, основанный на списке жетонов, взятых с карты. (Использует StringUtils из Apache Commons Lang).
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());
Как только регулярное выражение скомпилировано, сканирование входной строки, как правило, очень быстро (хотя, если ваше регулярное выражение является сложным или включает в себя обратное отслеживание, вам все равно нужно ориентироваться, чтобы это подтвердить!)
Ответ 2
Алгоритм
Одним из наиболее эффективных способов замены соответствующих строк (без регулярных выражений) является использование алгоритма Aho-Corasick с исполнителем Trie (произносится как "try" ), быстрый алгоритм хеширования и эффективный collections.
Простой код
Возможно, самый простой код для написания использует 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 );
}
Это замедляет большие тексты.
Быстрый код
Реализация Bor алгоритма Aho-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 ) );
}
}
Сам тест-код (JMH казался излишним):
long duration = System.nanoTime();
final String result = testBorAhoCorasick( text, definitions );
duration = System.nanoTime() - duration;
System.out.println( elapsed( duration ) );
1,000,000: 1000
Простой микро-бенчмарк с 1 000 000 символов и 1000 случайно размещенных строк для замены.
- testStringUtils: 25 секунд, 25533 милли.
- testBorAhoCorasick: 0 секунд, 68 миллисекунд
Нет соревнования.
10000: 1000
Использование 10 000 символов и 1000 подходящих строк для замены:
- testStringUtils: 1 секунда, 1402 милли.
- testBorAhoCorasick: 0 секунд, 37 миллисекунд
Деление закрывается.
1000: 10
Использование 1000 символов и 10 подходящих строк для замены:
- testStringUtils: 0 секунд, 7 миллисов
- testBorAhoCorasick: 0 секунд, 19 миллисекунд
Для коротких строк накладные расходы на настройку Aho-Corasick затмевают подход грубой силы на StringUtils.replaceEach.
Гибкий подход, основанный на длине текста, возможен, чтобы получить лучшее из обеих реализаций.
Реализация
Рассмотрим сравнение других реализаций текста длиной более 1 МБ, включая:
- 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
Документы
Документы и информация, относящиеся к алгоритму:
Ответ 3
Если вы собираетесь менять String много раз, то обычно более эффективно использовать 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, создается новый объект String, потому что строки являются неизменными. StringBuilder изменен, т.е. Его можно изменить как можно больше.
Ответ 4
StringBuilder будет выполнять более эффективную замену, поскольку его буфер массива символов может быть задан на требуемую длину. StringBuilder предназначен для более чем добавления!
Конечно, реальный вопрос: слишком ли это оптимизация? JVM очень хорошо справляется с созданием нескольких объектов и последующей сборкой мусора, и, как и все вопросы оптимизации, мой первый вопрос заключается в том, измеряете ли вы это и определили, что это проблема.
Ответ 5
Как насчет использования метода replaceAll()?
Ответ 6
Проверьте это:
String.Format(ул, УЛ [])
...
Например:
String.format( "Поместите свои% s, где ваши% s", "деньги", "рот" );
Ответ 7
Rythm java template engine теперь выпущен с новой функцией Режим интерполяции строк, который позволяет вам делать что-то вроде
String result = Rythm.render("@name is inviting you", "Diana");
В приведенном выше примере вы можете передать аргумент шаблону по позиции. Rythm также позволяет передавать аргументы по имени:
Map<String, Object> args = new HashMap<String, Object>();
args.put("title", "Mr.");
args.put("name", "John");
String result = Rythm.render("Hello @title @name", args);
Примечание. Ритм ОЧЕНЬ БЫСТРО, примерно в 2 - 3 раза быстрее, чем String.format и скорость, поскольку он компилирует шаблон в java-байтовый код, производительность выполнения очень близка к конкатенации с StringBuilder.
Ссылки:
- Проверьте полнофункциональную демонстрацию
- прочитайте краткое введение в ритм
- загрузите последний пакет или
- открыть его
Ответ 8
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();
}
Ответ 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();
}
Вот мои unit test случаи:
@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;
}