Замінити всі випадки рядка за допомогою StringBuilder?

Мені чогось не вистачає, або StringBuilder не має тієї самої функції "замінити всі випадки рядка A на рядок B", як це робить звичайний клас String? Функція заміни 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 . З javadocs Matcher:

 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();
    }
}

Подивіться на JavaDoc методу replaceAll класу String :

Замінює кожен підрядок цього рядка, який відповідає даному регулярному виразу, даною заміною. Виклик цього методу форми str.replaceAll (регулярний вираз, repl) дає точно такий же результат, як і вираз

java.util.regex.Pattern.compile (регулярний вираз) .matcher (str) .replaceAll (repl)

Як бачите, ви можете використовувати Pattern і Matcher для цього.

Клас org.apache.commons.lang3.text.StrBuilderв Apache Commons Lang дозволяє замінити:

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 ()

Використовуйте наступне:

/**
* 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);
    }
}

Ось на місці replaceAll, який змінить передане в StringBuilder. Я думав, що опублікую це, оскільки хотів замінити All на створення нового рядка.

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);
    }
}

Я був шокований, наскільки простий код для цього (з якоїсь причини я думав, що зміна 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 (Заміна рядка); У 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();
}