반응형
Java 한 번에 (또는 가장 쉬운 방법으로) 여러 개의 여러 개의 하위 계층
가장 많은 방법으로 많은 하위 계층을 교체해야합니다. string.replace를 사용하여 각 필드를 대체하는 다른 방법이 있습니까?
작업중 인 경우에는 작업하는 경우 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());
정규식이 널 일반적으로 사용되는 경우에도 스캔이 매우 빠 사용 (정규식이 복잡하거나 역 추적을 포함하는 경우에도 스캔이 사용됩니다!).
연산
일치하는 문자열 (정규 표현식없이)을 대체하는 가장 효율적인 방법 중 하나 는 아호-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 );
}
이것은 큰 텍스트에서 느려집니다.
빠른 코드
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 : 1,000
1,000,000 개의 문자와 1,000 개의 무작위로 배치 된이있는 간단한 마이크로 벤치 마크입니다.
- testStringUtils : 25 초, 25533 밀리
- testBorAhoCorasick : 0 초, 68 밀리
경쟁없이.
10,000 : 1,000
10,000 자 및 1,000 개의 일치하는 사용을 사용하여 대체 :
- testStringUtils : 1 초, 1402 밀리
- testBorAhoCorasick : 0 초, 37 밀리
분할이 종료됩니다.
1,000 : 10
1,000 자 및 10 개의 일치하는 것을 사용하여 대체 :
- testStringUtils : 0 초, 7 밀리
- testBorAhoCorasick : 0 초, 19 밀리
짧은 곳의 경우 Aho-Corasick을 설정하는 오버 헤드가 StringUtils.replaceEach.
두 구현 모두를 최대한 활용하기 위해 텍스트 길이를 기반으로하는 하이브리드 접근 방식이 가능합니다.
구현
다음을 포함하여 1MB보다 긴 텍스트에 대한 다른 구현을 비교해.
- 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
일반적으로 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을 교체 할 때마다 새로운 String 생성이됩니다. StringBuilder는 변경이 가능합니다. 즉, 원하는만큼 설명 수 있습니다.
이것은 나를 위해 일했습니다.
String result = input.replaceAll("string1|string2|string3","replacementString");
예 :
String input = "applemangobananaarefriuits";
String result = input.replaceAll("mango|are|ts","-");
System.out.println(result);
출력 : apple-banana-friui-
StringBuilder문자 배열 버퍼를 필요한 길이로 수행합니다. StringBuilder추가 이상을 위해 설계되었습니다!
물론 진짜 질문은 너무 멀리 최적화 된 여부입니다. JVM은 여러 가지 질문과 생성과 다음 가비지 수집을 매우 잘 처리하며 모든 최적화 질문과 매우 첫 번째 질문은 제출 측정하고 문제라고 결정했는지 여부.
replaceAll () 메서드를 사용하는 것은 무엇 입니까?
이제 자바 템플릿 엔진 인 Rythm 이 다음과 같은 작업을 수행 할 수있는 문자열 보간 모드 라는 새로운 기능과 함께 출시되었습니다 .
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 및 속도보다 약 2 ~ 3 배 빠르며 런타임 성능이 StringBuilder와의 연결에 매우 가깝습니다.
연결:
- 전체 기능 데모 확인
- Rythm에 대한 간략한 소개 읽기
- 최신 패키지 다운로드 또는
- 포크
이것을 확인하십시오 :
String.format (str, STR [])
...
예를 들면 :
String.format ( "당신의 % s를 당신의 % s가있는 곳에 두십시오", "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();
}
아래는 Todd Owen의 답변을 기반으로 합니다. 이 솔루션에는 정규식에서 특별한 의미를 갖는 문자가 대체에 포함되면 예기치 않은 결과가 발생할 수 있다는 문제가 있습니다. 또한 선택적으로 대소 문자를 구분하지 않는 검색을 수행 할 수 있기를 원했습니다. 내가 생각해 낸 것은 다음과 같습니다.
/**
* 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;
}
반응형
'IT' 카테고리의 다른 글
| Junit 단위 테스트 용 JVM 매개 변수를 설정하는 방법은 무엇입니까? (0) | 2020.09.05 |
|---|---|
| 그래프 검색과 트리 검색의 차이점은 무엇입니까? (0) | 2020.09.05 |
| 패키지 복원을 사용할 때 .nuget 폴더의 nuget.exe를 자동으로 업데이트하는 방법이? (0) | 2020.09.05 |
| 정규식 :? : 표기법 (물음표 및 콜론 표기법) (0) | 2020.09.05 |
| DB2 및 Oracle Perspective에서 CLOB와 BLOB의 차이점은 무엇입니까? (0) | 2020.09.05 |