How can I replace two strings in a way that one does not end up replacing the other?

Harnessing the power of Apache Commons

When dealing with multiple replacements, Apache Commons Lang comes to your rescue like a knight in shining armor. Its StringUtils.replaceEach() method is a nifty tool in your kit. All it needs is your input string, search strings in an array, and the corresponding replacements.

import org.apache.commons.lang3.StringUtils;

String text = "The cat sat on the mat.";
String[] searchList = new String[]{"cat", "mat"};
String[] replacementList = new String[]{"mat", "cat"};

text = StringUtils.replaceEach(text, searchList, replacementList); // A swiss-army knife for text manipulation


Achieving multiple non-interfering replacements is now as easy as pie with StringUtils! Just ensure your list of search strings is free from any duplicates or overlap. After all, it's wiser to prevent a storm than to sail in it!

Placeholder power-up: Unicode private use characters

To put a unique spin to your placeholder, assign it a Unicode Private Use Area (PUA) character. Like a secret spy code, these characters won't match any regular text and make swift work of temporary replacements. But remember, clean your input of any PUA characters beforehand.

char placeholder = '\uE000'; // Shhh... it's a secret Unicode PUA character!
text = text.replace("cat", String.valueOf(placeholder)).replace("mat", "cat").replace(String.valueOf(placeholder), "mat");


This tip can be a game-changer, especially with extensive and unpredictable datasets.

Mastering complex replacements with regex

When simpler methods don't fit the bill, put on your regex hat 🎩. Java's Matcher, Pattern, and StringBuffer classes are your solution to convoluted replacements.

import java.util.regex.*;

Pattern pattern = Pattern.compile("cat"); // Gotcha, cat!
Matcher matcher = pattern.matcher(text); // Let's match those sneaky cats
StringBuffer result = new StringBuffer(); // 'cause strings are too mainstream

while(matcher.find()) {
    matcher.appendReplacement(result, "mat"); // Swapping cats for mats, because why not?
}
matcher.appendTail(result);
text = result.toString();


The appendReplacement and appendTail methods keep your replacements on a tight leash, averting overlapping replacements. From nested replacements to dependent strings, tackle them all with regex wizardry!

Recursion to the rescue for nested operations

When replacements get tricky and dependent on each other, recursion steps in like a seasoned veteran.

public String recursiveReplace(String text, String search, String replacement) {
    if (!text.contains(search)) {
        return text;
    }
    text = text.replace(search, replacement);
    return recursiveReplace(text, search, replacement); // Dive into the recursion rabbit hole
}


But beware, every veteran has its weakness! Recursion in Java battles against stack size limits. Push it too hard, and you could ignite the infamous StackOverflowError.

Modernize with Java 8 Streams

Embrace modern Java practices with Java 8 streams. Bring readability and maintainability in your code without breaking a sweat.

List<String> tokens = Arrays.asList(text.split(" "));
tokens = tokens.stream()
               .map(token -> token.equals("cat") ? "mat" : token) // Unleashing lambda power
               .collect(Collectors.toList());
text = String.join(" ", tokens);


Turn your text into tokens and stream your way through enhanced text manipulations. Lucky for us, streams sport a suave look with pipeline operations and lambda expressions.