Reemplazar todas las ocurrencias de una Cadena usando StringBuilder?

Question

¿Me falta algo, o StringBuilder no tiene la misma función "reemplazar todas las apariciones de una cadena A con la secuencia B" que la clase String normal? La función de reemplazo StringBuilder no es lo mismo. ¿Hay alguna forma de hacerlo de manera más eficiente sin generar múltiples cadenas utilizando la clase String normal?

Answer 1

Bueno, se puede escribir un bucle:

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

Tenga en cuenta que en algunos casos puede ser más rápido usar lastIndexOf, trabajando desde la parte posterior. Sospecho que ese es el caso si reemplazas una cadena larga por una corta, por lo que cuando llegas al inicio, cualquier reemplazo tiene menos para copiar. De todos modos, esto debería darte un punto de partida.

Answer 2

java.util.regex.Pattern.matcher(CharSequence s) puede utilizar un StringBuilder como un argumento para que pueda buscar y reemplazar cada aparición de su patrón de uso de start() y al final() sin llamar builder.toString()

Answer 3

usted podría utilizar Pattern/Matcher. De los 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()); 

Answer 4

Mira JavaDoc de replaceAll método de cadena clase:

reemplaza cada subcadena de esta cadena que coincide con la dada expresión regular con el reemplazo dado. Una invocación de este método de la forma str.replaceAll (expresiones regulares, repl) produce exactamente el mismo resultado como la expresión

java.util.regex.Pattern.compile (regex) .matcher (str) .ReplaceAll (sust)

Como se puede ver se puede utilizar patrón y Matcher de hacer eso.

Answer 5

Usar la siguiente:

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

Answer 6

una Incluso simple es utilizar la cadena ReplaceAll función en sí. Puede escribirlo como

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

Answer 7

Aquí hay un in situ replaceAll que modificará el pasado en StringBuilder. Pensé que publicaría esto porque quería reemplazar todo con la creación de un nuevo String.

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

Me sorprendió lo fácil el código para hacer esto era (por alguna razón pensé cambiar el StringBuilder durante el uso de la matcher arrojaría del grupo de inicio/final, pero no lo hace).

Esto es probablemente más rápido que las otras respuestas de expresiones regulares porque el patrón ya está compilado y no está creando un nuevo String, pero no hice ningún benchmarking.

Answer 8

La clase org.apache.commons.lang3.text.StrBuilder en Apache Commons Lang permite reemplazos:

public StrBuilder replaceAll(String searchStr, String replaceStr) 

_{* Esto no reciben una expresión regular, pero una simple cadena.}

Answer 9

@ Adam: Creo que en el fragmento de código debe hacer un seguimiento de la posición de inicio para m.find() porque el reemplazo de cadena puede cambiar el desplazamiento después del último carácter coincidente.

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

Answer 10

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

Answer 11

¿Qué hay de crear un método y dejar String.replaceAll lo haga por usted:

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