ฉันต้องการแทนที่สตริงย่อยที่แตกต่างกันหลายสตริงด้วยวิธีที่มีประสิทธิภาพสูงสุด มีวิธีอื่นอีกหรือไม่ที่เป็นวิธีการบังคับที่ดุร้ายในการแทนที่แต่ละฟิลด์โดยใช้ string.replace
ฉันต้องการแทนที่สตริงย่อยที่แตกต่างกันหลายสตริงด้วยวิธีที่มีประสิทธิภาพสูงสุด มีวิธีอื่นอีกหรือไม่ที่เป็นวิธีการบังคับที่ดุร้ายในการแทนที่แต่ละฟิลด์โดยใช้ string.replace
คำตอบ:
หากสตริงที่คุณใช้งานอยู่มีความยาวมากหรือคุณใช้งานหลายสตริงการใช้ java.util.regex.Matcher อาจคุ้มค่า (ซึ่งต้องใช้เวลาในการคอมไพล์ล่วงหน้าดังนั้นจึงไม่มีประสิทธิภาพ หากข้อมูลของคุณมีขนาดเล็กมากหรือรูปแบบการค้นหาของคุณเปลี่ยนแปลงบ่อย)
ด้านล่างนี้เป็นตัวอย่างเต็มตามรายการโทเค็นที่นำมาจากแผนที่ (ใช้ 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());
เมื่อคอมไพล์นิพจน์ทั่วไปแล้วการสแกนสตริงอินพุตจะทำได้รวดเร็วมาก (แม้ว่านิพจน์ทั่วไปของคุณจะซับซ้อนหรือเกี่ยวข้องกับการย้อนรอยคุณก็ยังคงต้องทำการเปรียบเทียบเพื่อยืนยันสิ่งนี้!)
"%(" + StringUtils.join(tokens.keySet(), "|") + ")%";
วิธีที่มีประสิทธิภาพที่สุดวิธีหนึ่งในการแทนที่สตริงที่ตรงกัน (โดยไม่ใช้นิพจน์ทั่วไป) คือการใช้อัลกอริทึม Aho-CorasickกับTrie ที่มีประสิทธิภาพ(ออกเสียงว่า "ลอง") อัลกอริทึมการแฮชที่รวดเร็วและการใช้คอลเลคชันที่มีประสิทธิภาพ
โซลูชันง่ายๆใช้ประโยชน์จาก 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 );
}
สิ่งนี้จะทำให้ข้อความขนาดใหญ่ช้าลง
การใช้อัลกอริทึม Aho-Corasick ของ Borนำเสนอความซับซ้อนมากขึ้นเล็กน้อยซึ่งกลายเป็นรายละเอียดการใช้งานโดยใช้ด้านหน้าที่มีลายเซ็นวิธีเดียวกัน:
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 อักขระและ 1,000 สตริงที่วางแบบสุ่มเพื่อแทนที่
ไม่มีการแข่งขัน.
ใช้ 10,000 อักขระและ 1,000 สตริงที่ตรงกันเพื่อแทนที่:
การแบ่งจะปิดลง
ใช้ 1,000 อักขระและ 10 สตริงที่ตรงกันเพื่อแทนที่:
สำหรับสตริงสั้นค่าใช้จ่ายของการตั้งค่า Aho-Corasick StringUtils.replaceEachสุริยุปราคาวิธีแรงเดรัจฉานโดย
วิธีการแบบผสมผสานตามความยาวของข้อความเป็นไปได้เพื่อให้ได้ประโยชน์สูงสุดจากการใช้งานทั้งสองแบบ
พิจารณาเปรียบเทียบการใช้งานอื่น ๆ สำหรับข้อความที่มีความยาวมากกว่า 1 MB ได้แก่ :
เอกสารและข้อมูลที่เกี่ยวข้องกับอัลกอริทึม:
สิ่งนี้ใช้ได้ผลสำหรับฉัน:
String result = input.replaceAll("string1|string2|string3","replacementString");
ตัวอย่าง:
String input = "applemangobananaarefruits";
String result = input.replaceAll("mango|are|ts","-");
System.out.println(result);
เอาท์พุท: apple-banana-frui-
หากคุณกำลังจะเปลี่ยน 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 ใหม่จะถูกสร้างขึ้นเนื่องจาก Strings ไม่เปลี่ยนรูป StringBuilder นั้นไม่แน่นอนกล่าวคือสามารถเปลี่ยนแปลงได้มากเท่าที่คุณต้องการ
StringBuilderจะทำการแทนที่อย่างมีประสิทธิภาพมากขึ้นเนื่องจากบัฟเฟอร์อาร์เรย์อักขระสามารถระบุได้ตามความยาวที่ต้องการ StringBuilderถูกออกแบบมาให้มากกว่าการต่อท้าย!
แน่นอนคำถามที่แท้จริงคือนี่เป็นการเพิ่มประสิทธิภาพที่ไกลเกินไปหรือไม่? JVM ทำได้ดีมากในการจัดการการสร้างวัตถุหลายชิ้นและการรวบรวมขยะที่ตามมาและเช่นเดียวกับคำถามการเพิ่มประสิทธิภาพคำถามแรกของฉันคือคุณได้วัดสิ่งนี้และพิจารณาแล้วว่าเป็นปัญหาหรือไม่
วิธีการใช้replaceAll () เป็นอย่างไร?
str.replaceAll(search1, replace1).replaceAll(search2, replace2).replaceAll(search3, replace3).replaceAll(search4, replace4)
Rythm เอ็นจินเทมเพลต java เปิดตัวพร้อมคุณสมบัติใหม่ที่เรียกว่าString interpolation modeซึ่งให้คุณทำสิ่งต่างๆเช่น:
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);
หมายเหตุ Rythm เร็วมากเร็วกว่า String.format และ velocity ประมาณ 2 ถึง 3 เท่าเนื่องจากคอมไพล์เทมเพลตเป็นโค้ด java byte ประสิทธิภาพของรันไทม์ใกล้เคียงกับการเชื่อมต่อกับ StringBuilder มาก
ลิงค์:
"%cat% really needs some %beverage%."; นั้นไม่ใช่%รูปแบบที่กำหนดไว้ล่วงหน้าหรือไม่? จุดแรกของคุณเป็นเรื่องตลกยิ่งกว่านั้น JDK มี "ความสามารถเก่า ๆ " มากมายบางส่วนเริ่มจากยุค 90 ทำไมผู้คนถึงรำคาญการใช้งาน? ความคิดเห็นและการลงคะแนนของคุณไม่สมเหตุสมผลเลย
ด้านล่างจะขึ้นอยู่กับคำตอบของทอดด์โอเว่น วิธีแก้ปัญหานั้นมีปัญหาว่าหากการแทนที่มีอักขระที่มีความหมายพิเศษในนิพจน์ทั่วไปคุณจะได้รับผลลัพธ์ที่ไม่คาดคิด ฉันยังต้องการที่จะสามารถเลือกทำการค้นหาแบบไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่ได้ นี่คือสิ่งที่ฉันคิดขึ้น:
/**
* 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;
}
ตรวจสอบสิ่งนี้:
String.format(str,STR[])
ตัวอย่างเช่น:
String.format( "Put your %s where your %s is", "money", "mouth" );
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();
}
นี่คือการใช้งานคลาสเดียวเต็มรูปแบบตามคำตอบที่ยอดเยี่ยมข้างต้นจาก Dave Jarvisคำตอบจากเดฟจาร์วิสคลาสจะเลือกอัลกอริทึมที่ให้มาโดยอัตโนมัติเพื่อประสิทธิภาพสูงสุด (คำตอบนี้สำหรับผู้ที่ต้องการคัดลอกและวางอย่างรวดเร็ว)
package somepackage
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.ahocorasick.trie.Emit;
import org.ahocorasick.trie.Trie;
import org.ahocorasick.trie.Trie.TrieBuilder;
import org.apache.commons.lang3.StringUtils;
/**
* ReplaceStrings, This class is used to replace multiple strings in a section of text, with high
* time efficiency. The chosen algorithms were adapted from: https://stackoverflow.com/a/40836618
*/
public final class ReplaceStrings {
/**
* replace, This replaces multiple strings in a section of text, according to the supplied
* search and replace definitions. For maximum efficiency, this will automatically choose
* between two possible replacement algorithms.
*
* Performance note: If it is known in advance that the source text is long, then this method
* signature has a very small additional performance advantage over the other method signature.
* (Although either method signature will still choose the best algorithm.)
*/
public static String replace(
final String sourceText, final Map<String, String> searchReplaceDefinitions) {
final boolean useLongAlgorithm
= (sourceText.length() > 1000 || searchReplaceDefinitions.size() > 25);
if (useLongAlgorithm) {
// No parameter adaptations are needed for the long algorithm.
return replaceUsing_AhoCorasickAlgorithm(sourceText, searchReplaceDefinitions);
} else {
// Create search and replace arrays, which are needed by the short algorithm.
final ArrayList<String> searchList = new ArrayList<>();
final ArrayList<String> replaceList = new ArrayList<>();
final Set<Map.Entry<String, String>> allEntries = searchReplaceDefinitions.entrySet();
for (Map.Entry<String, String> entry : allEntries) {
searchList.add(entry.getKey());
replaceList.add(entry.getValue());
}
return replaceUsing_StringUtilsAlgorithm(sourceText, searchList, replaceList);
}
}
/**
* replace, This replaces multiple strings in a section of text, according to the supplied
* search strings and replacement strings. For maximum efficiency, this will automatically
* choose between two possible replacement algorithms.
*
* Performance note: If it is known in advance that the source text is short, then this method
* signature has a very small additional performance advantage over the other method signature.
* (Although either method signature will still choose the best algorithm.)
*/
public static String replace(final String sourceText,
final ArrayList<String> searchList, final ArrayList<String> replacementList) {
if (searchList.size() != replacementList.size()) {
throw new RuntimeException("ReplaceStrings.replace(), "
+ "The search list and the replacement list must be the same size.");
}
final boolean useLongAlgorithm = (sourceText.length() > 1000 || searchList.size() > 25);
if (useLongAlgorithm) {
// Create a definitions map, which is needed by the long algorithm.
HashMap<String, String> definitions = new HashMap<>();
final int searchListLength = searchList.size();
for (int index = 0; index < searchListLength; ++index) {
definitions.put(searchList.get(index), replacementList.get(index));
}
return replaceUsing_AhoCorasickAlgorithm(sourceText, definitions);
} else {
// No parameter adaptations are needed for the short algorithm.
return replaceUsing_StringUtilsAlgorithm(sourceText, searchList, replacementList);
}
}
/**
* replaceUsing_StringUtilsAlgorithm, This is a string replacement algorithm that is most
* efficient for sourceText under 1000 characters, and less than 25 search strings.
*/
private static String replaceUsing_StringUtilsAlgorithm(final String sourceText,
final ArrayList<String> searchList, final ArrayList<String> replacementList) {
final String[] searchArray = searchList.toArray(new String[]{});
final String[] replacementArray = replacementList.toArray(new String[]{});
return StringUtils.replaceEach(sourceText, searchArray, replacementArray);
}
/**
* replaceUsing_AhoCorasickAlgorithm, This is a string replacement algorithm that is most
* efficient for sourceText over 1000 characters, or large lists of search strings.
*/
private static String replaceUsing_AhoCorasickAlgorithm(final String sourceText,
final Map<String, String> searchReplaceDefinitions) {
// Create a buffer sufficiently large that re-allocations are minimized.
final StringBuilder sb = new StringBuilder(sourceText.length() << 1);
final TrieBuilder builder = Trie.builder();
builder.onlyWholeWords();
builder.ignoreOverlaps();
for (final String key : searchReplaceDefinitions.keySet()) {
builder.addKeyword(key);
}
final Trie trie = builder.build();
final Collection<Emit> emits = trie.parseText(sourceText);
int prevIndex = 0;
for (final Emit emit : emits) {
final int matchIndex = emit.getStart();
sb.append(sourceText.substring(prevIndex, matchIndex));
sb.append(searchReplaceDefinitions.get(emit.getKeyword()));
prevIndex = emit.getEnd() + 1;
}
// Add the remainder of the string (contains no more matches).
sb.append(sourceText.substring(prevIndex));
return sb.toString();
}
/**
* main, This contains some test and example code.
*/
public static void main(String[] args) {
String shortSource = "The quick brown fox jumped over something. ";
StringBuilder longSourceBuilder = new StringBuilder();
for (int i = 0; i < 50; ++i) {
longSourceBuilder.append(shortSource);
}
String longSource = longSourceBuilder.toString();
HashMap<String, String> searchReplaceMap = new HashMap<>();
ArrayList<String> searchList = new ArrayList<>();
ArrayList<String> replaceList = new ArrayList<>();
searchReplaceMap.put("fox", "grasshopper");
searchReplaceMap.put("something", "the mountain");
searchList.add("fox");
replaceList.add("grasshopper");
searchList.add("something");
replaceList.add("the mountain");
String shortResultUsingArrays = replace(shortSource, searchList, replaceList);
String shortResultUsingMap = replace(shortSource, searchReplaceMap);
String longResultUsingArrays = replace(longSource, searchList, replaceList);
String longResultUsingMap = replace(longSource, searchReplaceMap);
System.out.println(shortResultUsingArrays);
System.out.println("----------------------------------------------");
System.out.println(shortResultUsingMap);
System.out.println("----------------------------------------------");
System.out.println(longResultUsingArrays);
System.out.println("----------------------------------------------");
System.out.println(longResultUsingMap);
System.out.println("----------------------------------------------");
}
}
(เพิ่มสิ่งเหล่านี้ลงในไฟล์ pom ของคุณหากจำเป็น)
<!-- Apache Commons utilities. Super commonly used utilities.
https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.10</version>
</dependency>
<!-- ahocorasick, An algorithm used for efficient searching and
replacing of multiple strings.
https://mvnrepository.com/artifact/org.ahocorasick/ahocorasick -->
<dependency>
<groupId>org.ahocorasick</groupId>
<artifactId>ahocorasick</artifactId>
<version>0.4.0</version>
</dependency>