¿Cuál es una forma eficiente de reemplazar muchos caracteres en una cadena?

Question

El manejo de cadenas en Java es algo que trato de aprender a hacer bien. Actualmente quiero tomar una cadena y reemplazar cualquier personaje que encuentre.

Aquí está mi función actual ineficiente (y algo tonta IMO). Fue escrito para solo trabajar.

public String convertWord(String word) 
{ 
    return word.toLowerCase().replace('á', 'a') 
          .replace('é', 'e') 
          .replace('í', 'i') 
          .replace('ú', 'u') 
          .replace('ý', 'y') 
          .replace('ð', 'd') 
          .replace('ó', 'o') 
          .replace('ö', 'o') 
          .replaceAll("[-]", "") 
          .replaceAll("[.]", "") 
          .replaceAll("[/]", "") 
          .replaceAll("[æ]", "ae") 
          .replaceAll("[þ]", "th"); 
} 

me corrieron 1.000.000 carreras de la misma y se tomaron 8182ms. Entonces, ¿cómo debo proceder para cambiar esta función y hacerla más eficiente?

Solución encontrado:

la conversión de la función a esta

public String convertWord(String word) 
{ 
    StringBuilder sb = new StringBuilder(); 

    char[] charArr = word.toLowerCase().toCharArray(); 

    for(int i = 0; i < charArr.length; i++) 
    { 
     // Single character case 
     if(charArr[i] == 'á') 
     { 
      sb.append('a'); 
     } 
     // Char to two characters 
     else if(charArr[i] == 'þ') 
     { 
      sb.append("th"); 
     } 
     // Remove 
     else if(charArr[i] == '-') 
     { 
     } 
     // Base case 
     else 
     { 
      sb.append(word.charAt(i)); 
     } 
    } 

    return sb.toString(); 
} 

La ejecución de esta función de 1.000.000 veces tarda 518ms. Entonces creo que eso es lo suficientemente eficiente. Gracias por la ayuda chicos :)

Answer 1

Se puede crear una tabla de String [] que es Character.MAX_VALUE de longitud. (Incluyendo la asignación a minúsculas)

A medida que las sustituciones se hicieron más complejas, el tiempo para llevarlas a cabo seguiría siendo el mismo.

private static final String[] REPLACEMENT = new String[Character.MAX_VALUE+1]; 
static { 
    for(int i=Character.MIN_VALUE;i<=Character.MAX_VALUE;i++) 
     REPLACEMENT[i] = Character.toString(Character.toLowerCase((char) i)); 
    // substitute 
    REPLACEMENT['á'] = "a"; 
    // remove 
    REPLACEMENT['-'] = ""; 
    // expand 
    REPLACEMENT['æ'] = "ae"; 
} 

public String convertWord(String word) { 
    StringBuilder sb = new StringBuilder(word.length()); 
    for(int i=0;i<word.length();i++) 
     sb.append(REPLACEMENT[word.charAt(i)]); 
    return sb.toString(); 
} 

Answer 2

Mi sugerencia sería:

• convertir la cadena en un char [] array
• Ejecutar a través de la matriz, las pruebas de cada caracteres de uno en uno (por ejemplo, con un interruptor declaración) y reemplazarlo si es necesario
• convertir el [] matriz de caracteres de nuevo a una cadena

Creo que este es probablemente el rendimiento más rápido obtendrá en Java puro.

EDIT: Me doy cuenta de que estás haciendo algunos cambios que cambian la longitud de la cadena. En este caso, se aplica el mismo principio, sin embargo, debe mantener dos matrices e incrementar un índice de origen y un índice de destino por separado. Es posible que también necesite cambiar el tamaño de la matriz de destino si se queda sin espacio objetivo (es decir, reasignar una matriz más grande y crear una matriz de destino existente en ella)

Answer 3

Dudo que pueda acelerar el 'reemplazo de caracteres' en absoluto De Verdad. En cuanto al reemplazo de expresiones regulares, puede compilar las expresiones regulares de antemano

Answer 4

Use la función String.replaceAll. Buen artículo similar con lo que quiere: link

Answer 5

Cada vez que tenemos problemas como este, utilizamos expresiones regulares, ya que son la manera más rápida de lidiar con lo que está tratando de hacer.

¿Ya ha probado las expresiones regulares?

Answer 6

Lo que veo que es ineficiente es que vas a verificar nuevamente los caracteres que ya han sido reemplazados, lo cual es inútil.

que tendría la charArray de la instancia String, iterar sobre ella, y para cada correo no deseado carácter de una serie de if-else así:

char[] array = word.toCharArray(); 
for(int i=0; i<array.length; ++i){ 
    char currentChar = array[i]; 
    if(currentChar.equals('é')) 
     array[i] = 'e'; 
    else if(currentChar.equals('ö')) 
     array[i] = 'o'; 
    else if(//... 
} 

Answer 7

Mi primera opción sería utilizar un StringBuilder porque necesita eliminar algunos caracteres de la cadena.

La segunda opción sería repetir el lanzamiento de la matriz de caracteres y agregar el carácter tratado a otra serie del tamaño inicial de la cadena.Entonces necesitaría copiar la matriz para recortar las posibles posiciones no utilizadas.

Después de eso, me gustaría hacer algunas pruebas de rendimiento para ver bruja uno es mejor.

Answer 8

Mi aplicación se basa en la tabla de búsqueda.

public static String convertWord(String str) { 
    char[] words = str.toCharArray(); 
    char[] find = {'á','é','ú','ý','ð','ó','ö','æ','þ','-','.', 
      '/'}; 
    String[] replace = {"a","e","u","y","d","o","o","ae","th"}; 
    StringBuilder out = new StringBuilder(str.length()); 
    for (int i = 0; i < words.length; i++) { 
     boolean matchFailed = true; 
     for(int w = 0; w < find.length; w++) { 
      if(words[i] == find[w]) { 
       if(w < replace.length) { 
        out.append(replace[w]); 
       } 
       matchFailed = false; 
       break; 
      } 
     } 
     if(matchFailed) out.append(words[i]); 
    } 
    return out.toString(); 
}