Remove all occurrences of char from string

Just the right choice: choosing the suitable method

Different methods for different needs

Determining the appropriate method to employ largely hinges on your specific needs:

• String's replace(): Quite handy for straight-to-the-point character excision.
• replaceAll() with regex: Useful when you need to perform a grain surgery on complex patterns.
• StringUtils.remove(): A relevant method, quite the muscle guy in the Apache Commons Lang library.
• StringBuilder: The go-to guy when working in a loop, or appending characters frequently.

Regular expressions: a double-edged sword

Operating with regular expressions has its pros and cons:

• Have your regex patterns pre-compile their own workout plans if you're using them inside a loop.
• replaceAll() might bring along extra MS Excel-calculations-level processing power just to get the job done.

How StringBuilder plays its game

When dealing with long strings or multiple modifications, consider having StringBuilder on your team:

StringBuilder sb = new StringBuilder("example");
for (int i = 0; i < sb.length(); i++) {
    if (sb.charAt(i) == 'e') {
        sb.deleteCharAt(i--); // "Zap! e's gone!"
    }
}
String result = sb.toString(); // result: "xampl"


This approach can be faster than a cheetah with a jetpack, mostly because it avoids creating new String objects faster than I can find my keys in the morning.

Java 8: The Next Generation

Learn to leverage Java 8's streams and lambdas for transformations, similar to a Decepticon, but with subtler overhead:

String result = "example".chars()
    .filter(c -> c != 'e') // filtering characters like picking out raisins from your cookies
    .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
    .toString(); // result: "xampl"


Advanced tactics and trouble spots

Guarding against gotchas

As straightforward as string manipulation might seem, be ready for these potential issues:

• Character encoding: Verify the correct encoding of your string for a smooth operation.
• Escape sequences in regex: Remember to ditch special characters properly to avoid inviting them to the replaceAll() party.
• Concurrent modification: Understand implications on indices or ordering when altering strings within a loop or stream.

Going rogue: the split and join strategy

When the situation calls for it, wield the Split-Join Jutsu:

String[] parts = "example".split("e"); // Performing a "surgical removal" on 'e'
String result = String.join("", parts); // Stitching it back together, 'e'-less. // result: "xampl"


This tactic slices up the string around the target character and glues the others back together, effectively removing sightings of the targeted character.