Difference between String replace() and replaceAll

问题:

What\'s the difference between java.lang.String \'s replace() and replaceAll() methods, other than later uses regex? For simple substitutions like, replace . with / , is there any difference?

回答1:

In java.lang.String, the replace method either takes a pair of char\'s or a pair of CharSequence\'s (of which String is a subclass, so it\'ll happily take a pair of String\'s). The replace method will replace all occurrences of a char or CharSequence. On the other hand, both String arguments to replaceFirst and replaceAll are regular expressions (regex). Using the wrong function can lead to subtle bugs.

回答2:

Q: What\'s the difference between the java.lang.String methods replace() and replaceAll(), other than that the later uses regex.

A: Just the regex. They both replace all :)

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

PS:

There\'s also a replaceFirst() (which takes a regex)

回答3:

The replace() method is overloaded to accept both a primitive char and a CharSequence as arguments.

Now as far as the performance is concerned, the replace() method is a bit faster than replaceAll() because the latter first compiles the regex pattern and then matches before finally replacing whereas the former simply matches for the provided argument and replaces.

Since we know the regex pattern matching is a bit more complex and consequently slower, then preferring replace() over replaceAll() is suggested whenever possible.

For example, for simple substitutions like you mentioned, it is better to use:

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

instead of:

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

Note: the above conversion method arguments are system-dependent.

回答4:

Both replace() and replaceAll() replace all occurrences in the String.

Examples

I always find examples helpful to understand the differences.

replace()

Use replace() if you just want to replace some char with another char or some String with another String (actually CharSequence).

Example 1

Replace all occurrences of the character x with 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_

Example 2

Replace all occurrences of the string fish with 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()

Use replaceAll() if you want to use a regular expression pattern.

Example 3

Replace any number with an 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

Example 4

Remove all whitespace.

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

See also

Documentation

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

Regular Expressions

• Tutorial
• List of patterns

回答5:

String replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

String replaceAll(String regex, String replacement

Replaces each substring of this string that matches the given regular expression with the given replacement.

回答6:

1. Both replace() and replaceAll() accepts two arguments and replaces all occurrences of the first substring(first argument) in a string with the second substring (second argument).
2. replace() accepts a pair of char or charsequence and replaceAll() accepts a pair of regex.

3. It is not true that replace() works faster than replaceAll() since both uses the same code in its implementation

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

Now the question is when to use replace and when to use replaceAll(). When you want to replace a substring with another substring regardless of its place of occurrence in the string use replace(). But if you have some particular preference or condition like replace only those substrings at the beginning or end of a string use replaceAll(). Here are some examples to prove my point:

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

回答7:

As alluded to in wickeD\'s answer, with replaceAll the replacement string is handled differently between replace and replaceAll. I expected a[3] and a[4] to have the same value, but they are different.

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

The output of this is:

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

This is different from perl where the replacement does not require the extra level of escaping:

#!/bin/perl
$esc = \"\\\\\";
$s = \"X\";

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

which prints \\X 2

This can be quite a nuisance, as when trying to use the value returned by java.sql.DatabaseMetaData.getSearchStringEscape() with replaceAll().

回答8:

Old thread I know but I am sort of new to Java and discover one of it\'s strange things. I have used String.replaceAll() but get unpredictable results.

Something like this mess up the string:

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

So I designed this function to get around the weird problem:

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

Which make you able to do:

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

回答9:

There are two replace() method in Java, one of them takes character as first parameter and other takes CharSequence (which is super Interface for String, Stringbuffer, etc) as first parameter. Both these methods replaces all occurrences of char or CharSequence with the value you provide in 2nd parameter.

ReplaceAll method takes Regular expression as first parameter, so you need to give it some Regex and the matched content will be replaced by the String you pass in 2nd parameter.

For complete difference between replace()and replaceAll() method you can refer here Difference between replace(), replaceAll() and replaceFirst() method in Java String

回答10:

replace() method doesn\'t uses regex pattern whereas replaceAll() method uses regex pattern. So replace() performs faster than replaceAll().

回答11:

replace and replaceAll change the string and char in all the words but replaceAll supports regex (Regular Expression). There is also replaceFirst which is like replaceAll in that they both support regex and the both change strings and chars, the difference between them is that when you use replaceFirst with regex it replaces the first regex ONLY.

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

And output:

Ahmed Ahmed Hafez

Omar-Ahmed-Hafez

回答12:

replace works on char data type but replaceAll works on String datatype and both replace the all occurrences of first argument with second argument.