StringBuilder를 사용하여 문자열의 모든 항목을 교체 하시겠습니까?

내가 뭔가를 놓치고 있거나 StringBuilder에 일반 String 클래스가 수행하는 동일한 "문자열 A의 모든 발생을 문자열 B로 교체"기능이 부족합니까? StringBuilder 교체 기능은 완전히 동일하지 않습니다. 일반 String 클래스를 사용하여 여러 문자열을 생성하지 않고 더 효율적으로이를 수행 할 수있는 방법이 있습니까?

글쎄, 루프를 작성할 수 있습니다.

public static void replaceAll(StringBuilder builder, String from, String to)
{
    int index = builder.indexOf(from);
    while (index != -1)
    {
        builder.replace(index, index + from.length(), to);
        index += to.length(); // Move to the end of the replacement
        index = builder.indexOf(from, index);
    }
}

경우에 lastIndexOf따라 뒤쪽에서 작업하는 것이 더 빠를 수 있습니다 . 긴 문자열을 짧은 문자열로 바꾸는 경우가 그렇다고 생각합니다. 따라서 처음부터 교체 할 경우 복사 할 것이 적습니다. 어쨌든 이것은 시작점을 제공 할 것입니다.

Pattern / Matcher를 사용할 수 있습니다 . Matcher javadocs에서 :

 Pattern p = Pattern.compile("cat");
 Matcher m = p.matcher("one cat two cats in the yard");
 StringBuffer sb = new StringBuffer();
 while (m.find()) {
     m.appendReplacement(sb, "dog");
 }
 m.appendTail(sb);
 System.out.println(sb.toString());

@Adam : 코드 스 니펫에서 m.find ()의 시작 위치를 추적해야한다고 생각합니다. 문자열 교체는 마지막 문자가 일치 한 후 오프셋을 변경할 수 있기 때문입니다.

public static void replaceAll(StringBuilder sb, Pattern pattern, String replacement) {
    Matcher m = pattern.matcher(sb);
    int start = 0;
    while (m.find(start)) {
        sb.replace(m.start(), m.end(), replacement);
        start = m.start() + replacement.length();
    }
}

String 클래스 의 replaceAll 메소드의 JavaDoc을 살펴보십시오 .

주어진 정규식과 일치하는이 문자열의 각 부분 문자열을 주어진 대체로 바꿉니다. str.replaceAll (regex, repl) 형식의이 메소드를 호출하면 표현식과 정확히 동일한 결과가 생성됩니다.

java.util.regex.Pattern.compile (regex) .matcher (str) .replaceAll (repl)

보시다시피 Pattern 및 Matcher 를 사용 하여 수행 할 수 있습니다 .

클래스 org.apache.commons.lang3.text.StrBuilder에서 아파치 코 몬즈 랭은 교체 할 수 있습니다 :

public StrBuilder replaceAll(String searchStr, String replaceStr)

_{* 정규식이 아닌 간단한 문자열을받습니다.}

간단한 것조차도 String ReplaceAll 함수 자체를 사용하는 것입니다. 다음과 같이 쓸 수 있습니다.

StringBuilder sb = new StringBuilder("Hi there, are you there?")
System.out.println(Pattern.compile("there").matcher(sb).replaceAll("niru"));

예. String.replaceAll()방법 을 사용 하는 것은 매우 간단합니다 .

package com.test;

public class Replace {

    public static void main(String[] args) {
        String input = "Hello World";
        input = input.replaceAll("o", "0");
        System.out.println(input);
    }
}

산출:

Hell0 W0rld

StringBuilder.replace(int start, int end, String str)대신 사용하고 싶다면 여기로 가십시오.

public static void main(String args[]) {
    StringBuilder sb = new StringBuilder("This is a new StringBuilder");

    System.out.println("Before: " + sb);

    String from = "new";
    String to = "replaced";
    sb = sb.replace(sb.indexOf(from), sb.indexOf(from) + from.length(), to);

    System.out.println("After: " + sb);
}

산출:

Before: This is a new StringBuilder
After: This is a replaced StringBuilder

java.util.regex.Pattern.matcher (CharSequence s) 는 StringBuilder를 인수로 사용할 수 있으므로 builder.toString ()을 호출하지 않고도 start () 및 end ()를 사용하여 패턴의 각 발생을 찾고 바꿀 수 있습니다.

다음을 사용하십시오.

/**
* Utility method to replace the string from StringBuilder.
* @param sb          the StringBuilder object.
* @param toReplace   the String that should be replaced.
* @param replacement the String that has to be replaced by.
* 
*/
public static void replaceString(StringBuilder sb,
                                 String toReplace,
                                 String replacement) {      
    int index = -1;
    while ((index = sb.lastIndexOf(toReplace)) != -1) {
        sb.replace(index, index + toReplace.length(), replacement);
    }
}

다음은 StringBuilder에서 전달 된 내용을 수정하는 replaceAll입니다. 새 문자열을 만드는 대신 replaceAll을 수행하려고 할 때 이것을 게시 할 것이라고 생각했습니다.

public static void replaceAll(StringBuilder sb, Pattern pattern, String replacement) {
    Matcher m = pattern.matcher(sb);
    while(m.find()) {
        sb.replace(m.start(), m.end(), replacement);
    }
}

이 작업을 수행하는 코드가 얼마나 간단한 지 충격을 받았습니다 (어떤 이유로 Matcher를 사용하는 동안 StringBuilder를 변경하면 그룹 시작 / 종료가 발생한다고 생각했지만 그렇지 않습니다).

패턴이 이미 컴파일되어 있고 새 문자열을 만들지 않았지만 벤치마킹을 수행하지 않았기 때문에 이것은 다른 정규식 답변보다 빠를 것입니다.

방법을 만들고 String.replaceAll당신을 위해 그것을 시키는 것은 어떻습니까?

public static void replaceAll(StringBuilder sb, String regex, String replacement)
{
    String aux = sb.toString();
    aux = aux.replaceAll(regex, replacement);
    sb.setLength(0);
    sb.append(aux);     
}

public static String replaceCharsNew(String replaceStr,Map<String,String> replaceStrMap){
        StringBuilder replaceStrBuilder = new StringBuilder(replaceStr);
        Set<String> keys=replaceStrMap.keySet();
        for(String invalidChar:keys){
            int index = -1;
            while((index=replaceStrBuilder.indexOf(invalidChar,index)) !=-1){
                replaceStrBuilder.replace(index,index+invalidChar.length(),replaceStrMap.get(invalidChar));
            }
        }
        return replaceStrBuilder.toString();
    }

이 방법을 찾았습니다. Matcher.replaceAll (String replacement); java.util.regex.Matcher.java에서 더 많은 것을 볼 수 있습니다.

 /**
 * Replaces every subsequence of the input sequence that matches the
 * pattern with the given replacement string.
 *
 * <p> This method first resets this matcher.  It then scans the input
 * sequence looking for matches of the pattern.  Characters that are not
 * part of any match are appended directly to the result string; each match
 * is replaced in the result by the replacement string.  The replacement
 * string may contain references to captured subsequences as in the {@link
 * #appendReplacement appendReplacement} method.
 *
 * <p> Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in
 * the replacement string may cause the results to be different than if it
 * were being treated as a literal replacement string. Dollar signs may be
 * treated as references to captured subsequences as described above, and
 * backslashes are used to escape literal characters in the replacement
 * string.
 *
 * <p> Given the regular expression <tt>a*b</tt>, the input
 * <tt>"aabfooaabfooabfoob"</tt>, and the replacement string
 * <tt>"-"</tt>, an invocation of this method on a matcher for that
 * expression would yield the string <tt>"-foo-foo-foo-"</tt>.
 *
 * <p> Invoking this method changes this matcher's state.  If the matcher
 * is to be used in further matching operations then it should first be
 * reset.  </p>
 *
 * @param  replacement
 *         The replacement string
 *
 * @return  The string constructed by replacing each matching subsequence
 *          by the replacement string, substituting captured subsequences
 *          as needed
 */
public String replaceAll(String replacement) {
    reset();
    StringBuffer buffer = new StringBuffer(input.length());
    while (find()) {
        appendReplacement(buffer, replacement);
    }
    return appendTail(buffer).toString();
}