replace() vs replaceAll() in Java

Direct Answer

replace(CharSequence target, CharSequence replacement) treats the target literally. replaceAll(String regex, String replacement) treats the first argument as a regular expression, and $ and backslash have special meaning in the replacement string. Prefer replace for fixed text; when replacement text is literal with replaceAll, use Matcher.quoteReplacement.

Code Example

public class ReplaceDemo {
    public static void main(String[] args) {
        String s = "a.b.c.d";

        // replace() — treats '.' as literal dot
        System.out.println(s.replace(".", "-"));     // a-b-c-d

        // replaceAll() — '.' is regex metachar = any character
        System.out.println(s.replaceAll(".", "-"));  // ------- (replaces every char!)

        // replaceAll() correct use — escape the dot
        System.out.println(s.replaceAll("\\.", "-")); // a-b-c-d

        // replaceAll() genuine use case — collapse multiple spaces
        String messy = "Hello    World   !";
        System.out.println(messy.replaceAll("\\s+", " ")); // Hello World !

        // replaceAll() — remove all digits
        String code = "abc123def456";
        System.out.println(code.replaceAll("\\d+", ""));   // abcdef

        // replaceFirst() — only the first match
        System.out.println("aabbcc".replaceFirst("b", "X")); // aaXbcc
    }
}

Common Mistakes & Pitfalls

• Using replaceAll() for literal text — if the target holds ., +, |, or (, it matches far more than intended. replace() is the safe literal choice and needs no escaping.
• The dot trap — replaceAll(".", "-") replaces every character, not the dots. You meant replace(".", "-"), or replaceAll("\\.", "-") if you specifically need regex.
• Forgetting the replacement string is special too — $ and \ in the second argument of replaceAll() mean group references and escapes; inserting a literal $5 needs Matcher.quoteReplacement().
• Thinking replace() only swaps the first match — it replaces all occurrences, exactly like replaceAll(). The name difference is regex vs literal, not quantity; replaceFirst() is the one that stops at one.
• Recompiling a regex every call — repeatedly calling replaceAll() in a loop recompiles the pattern each time; precompile with Pattern.compile() and reuse the Matcher.