Diferencia entre String replace () y replaceAll ()

¿Cuál es la diferencia entre los métodos replace() y replaceAll() , aparte de los usos posteriores de replaceAll() regulares? Para sustituciones simples como, reemplazar . con / , ¿hay alguna diferencia?

En java.lang.String , el método de replace toma un par de char o un par de CharSequence (de los cuales String es una subclase, por lo que felizmente tomará un par de String). El método de reemplazo reemplazará todas las ocurrencias de un char o CharSequence . Por otro lado, ambos argumentos de String para replaceFirst y replaceAll son expresiones regulares (expresiones regulares). Usar la función incorrecta puede conducir a errores sutiles.

P: ¿Cuál es la diferencia entre los métodos java.lang.String replace() y replaceAll() , salvo que el último usa regex.

A: solo la expresión regular. Ambos reemplazan a todos 🙂

http://docs.oracle.com/javase/6/docs/api/java/lang/String.html

PD:

También hay un replaceFirst() (que toma una expresión regular)

El método replace() está sobrecargado para aceptar tanto un char primitivo como un CharSequence como argumentos.

Ahora, en lo que respecta al rendimiento, el método replace() es un poco más rápido que replaceAll() porque este último primero comstack el patrón regex y luego coincide antes de reemplazarlo por último, mientras que el primero simplemente coincide con el argumento proporcionado y reemplaza.

Como sabemos que la coincidencia del patrón de expresiones regulares es un poco más compleja y, por consiguiente, más lenta, se sugiere preferir replace() por replaceAll() siempre que sea posible.

Por ejemplo, para sustituciones simples como las mencionadas, es mejor usar:

 replace('.', '\\'); 

en lugar de:

 replaceAll("\\.", "\\\\"); 

Nota: los argumentos del método de conversión anterior dependen del sistema.

Both replace() y replaceAll() reemplazan todas las ocurrencias en String.

Ejemplos

Siempre encuentro ejemplos útiles para entender las diferencias.

replace()

Use replace() si solo quiere reemplazar un char con otro char o un String con otro String (en realidad, CharSequence ).

Ejemplo 1

Reemplace todas las ocurrencias del carácter x con o .

 String myString = "__x___x___x_x____xx_"; char oldChar = 'x'; char newChar = 'o'; String newString = myString.replace(oldChar, newChar); // __o___o___o_o____oo_ 

Ejemplo 2

Reemplazar todas las ocurrencias del fish cuerda con sheep .

 String myString = "one fish, two fish, three fish"; String target = "fish"; String replacement = "sheep"; String newString = myString.replace(target, replacement); // one sheep, two sheep, three sheep 

replaceAll()

Utilice replaceAll() si desea usar un patrón de expresión regular .

Ejemplo 3

Reemplace cualquier número con una x .

 String myString = "__1_6____3__6_345____0"; String regex = "\\d"; String replacement = "x"; String newString = myString.replaceAll(regex, replacement); // __x_x____x__x_xxx____x 

Ejemplo 4

Eliminar todos los espacios en blanco.

 String myString = " Horse Cow\n\n \r Camel \t\t Sheep \n Goat "; String regex = "\\s"; String replacement = ""; String newString = myString.replaceAll(regex, replacement); // HorseCowCamelSheepGoat 

Ver también

Documentación

  • replace(char oldChar, char newChar)
  • replace(CharSequence target, CharSequence replacement)
  • replaceAll(String regex, String replacement)
  • replaceFirst(String regex, String replacement)

Expresiones regulares

  • Tutorial
  • Lista de patrones
 String replace(char oldChar, char newChar) 

Devuelve una nueva cadena resultante de reemplazar todas las ocurrencias de oldChar en esta cadena con newChar.

 String replaceAll(String regex, String replacement 

Reemplaza cada subcadena de esta cadena que coincide con la expresión regular dada con el reemplazo dado.

  1. Both replace () y replaceAll () aceptan dos argumentos y reemplazan todas las apariciones de la primera subcadena (primer argumento) en una cadena con la segunda subcadena (segundo argumento).
  2. replace () acepta un par de char o charsequence y replaceAll () acepta un par de expresiones regulares.
  3. No es cierto que replace () funcione más rápido que replaceAll () ya que ambos usan el mismo código en su implementación

    Pattern.compile (regex) .matcher (this) .replaceAll (reemplazo);

Ahora la pregunta es cuándo usar replace y cuándo usar replaceAll (). Cuando desee reemplazar una subcadena con otra subcadena, independientemente de su lugar de ocurrencia en la cadena, utilice replace (). Pero si tiene alguna preferencia o condición particular como reemplazar solo esas subcadenas al principio o al final de una cadena, use replaceAll (). Aquí hay algunos ejemplos para probar mi punto:

 String str = new String("==qwerty==").replaceAll("^==", "?"); \\str: "?qwerty==" String str = new String("==qwerty==").replaceAll("==$", "?"); \\str: "==qwerty?" String str = new String("===qwerty==").replaceAll("(=)+", "?"); \\str: "?qwerty?" 

Como se alude en la respuesta de wickeD, con replaceToall la cadena de reemplazo se maneja de manera diferente entre replace y replaceAll. Esperaba que [3] y [4] tuvieran el mismo valor, pero son diferentes.

 public static void main(String[] args) { String[] a = new String[5]; a[0] = "\\"; a[1] = "X"; a[2] = a[0] + a[1]; a[3] = a[1].replaceAll("X", a[0] + "X"); a[4] = a[1].replace("X", a[0] + "X"); for (String s : a) { System.out.println(s + "\t" + s.length()); } } 

El resultado de esto es:

 \ 1 X 1 \X 2 X 1 \X 2 

Esto es diferente de Perl, donde el reemplazo no requiere el nivel extra de escape:

 #!/bin/perl $esc = "\\"; $s = "X"; $s =~ s/X/${esc}X/; print "$s " . length($s) . "\n"; 

que imprime \ X 2

Esto puede ser bastante molesto, como cuando se intenta usar el valor devuelto por java.sql.DatabaseMetaData.getSearchStringEscape () con replaceAll ().

Viejo hilo lo sé pero soy algo nuevo en Java y descubro una de sus cosas extrañas. He usado String.replaceAll() pero obtengo resultados impredecibles.

Algo así arruina la cadena:

 sUrl = sUrl.replaceAll( "./", "//").replaceAll( "//", "/"); 

Así que diseñé esta función para evitar el extraño problema:

 //String.replaceAll does not work OK, that's why this function is here public String strReplace( String s1, String s2, String s ) { if((( s == null ) || (s.length() == 0 )) || (( s1 == null ) || (s1.length() == 0 ))) { return s; } while( (s != null) && (s.indexOf( s1 ) >= 0) ) { s = s.replace( s1, s2 ); } return s; } 

Lo que te permite hacer:

 sUrl=this.strReplace("./", "//", sUrl ); sUrl=this.strReplace( "//", "/", sUrl ); 

Hay dos métodos de reemplazo () en Java, uno de ellos toma carácter como primer parámetro y otro toma CharSequence (que es superinterfaz para String, Stringbuffer, etc.) como primer parámetro. Ambos métodos reemplazan todas las ocurrencias de char o CharSequence con el valor que usted proporciona en el 2do parámetro.

El método ReplaceAll toma la expresión regular como primer parámetro, por lo que debe darle un poco de Regex y el contenido coincidente será reemplazado por la cadena que pase en el segundo parámetro.

Para una diferencia completa entre el método replace () y replaceAll (), puede consultar aquí Diferencia entre los métodos replace (), replaceAll () y replaceFirst () en Java String

replace() método replace() no usa el patrón regex mientras que el método replaceAll() usa un patrón regex. Entonces replace() funciona más rápido que replaceAll() .

replace y replaceAll cambie la string y char en todas las palabras pero replaceAll admite expresiones regulares (Expresión regular). También hay replaceFirst que es como replaceAll que ambos admiten replaceAll regulares y ambos cambian cadenas y caracteres, la diferencia entre ellos es que cuando usas replaceFirst con regex, SÓLO reemplaza la primera expresión regular.

 // Java_codes_for_more_explanation ; String name1 = "Omar Ahmed Hafez" ; name1 = name1.replace("Omar", "Ahmed"); System.out.println(name1); ///////////////////////////////////////////// String name2 = "Omar Ahmed Hafez" ; name2 = name2.replaceAll("\\s", "-"); // The first parameter("\\W") is regex and it mean replace #ALL // space by "-" and it change All regex in the line as its replaceALL System.out.println(name2); //////////////////////////////////////////// String name3 = "Omar Ahmed Hafez" ; name3 = name3.replaceFirst ("\\s", "-"); // The first parameter("\\W") is regex and it mean replace #FIRST // space ONLT by "-" (as //it replaceFirst so it replace the first // regex only :) System.out.println(name3); 

Y salida:

 Ahmed Ahmed Hafez Omar-Ahmed-Hafez 

replace works en el tipo de datos char pero replaceAll funciona en el tipo de datos String y ambos reemplazan todas las instancias del primer argumento con el segundo argumento.