Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


1. Overview

In this tutorial, we're going to be looking at various means we can remove or replace part of a String in Java.

We'll explore removing and/or replacing a substring using a String API, then using a StringBuilder API and finally using the StringUtils class of Apache Commons library.

As a bonus, we'll also look into replacing an exact word using the String API and the Apache Commons RegExUtils class.

2. String API

One of the simplest and straightforward methods of replacing a substring is using the replace, replaceAll or replaceFirst of a String class.

The replace() method takes two arguments – target and replacement text:

String master = "Hello World Baeldung!";
String target = "Baeldung";
String replacement = "Java";
String processed = master.replace(target, replacement);

The above snippet will yield this output:

Hello World Java!

If a regular expression is required in choosing the target, then the replaceAll() or replaceFirst() should be the method of choice. As their name implies, replaceAll() will replace every matched occurrence, while the replaceFirst() will replace the first matched occurrence:

String master2 = "Welcome to Baeldung, Hello World Baeldung";
String regexTarget = "(Baeldung)$";
String processed2 = master2.replaceAll(regexTarget, replacement);

The value of processed2 will be:

Welcome to Baeldung, Hello World Java

It's because the regex supplied as regexTarget will only match the last occurrence of Baeldung. In all examples given above, we can use an empty replacement and it'll effectively remove a target from a master.

3. StringBuilder API

We can also manipulate text in Java using the StringBuilder classThe two methods here are delete() and replace().

We can construct an instance of a StringBuilder from an existing String and then use the methods mentioned to perform the String manipulation as desired:

String master = "Hello World Baeldung!";
String target = "Baeldung";
String replacement = "Java";

int startIndex = master.indexOf(target);
int stopIndex = startIndex + target.length();

StringBuilder builder = new StringBuilder(master);

Now we can remove the target with the delete():

builder.delete(startIndex, stopIndex);

We can as well use the replace() to update the master:

builder.replace(startIndex, stopIndex, replacement);

One apparent difference between using the StringBuilder and the String API is that we've to get the start and the stop index of the target String ourselves.

4. StringUtils Class

Another method we'll consider is the Apache Commons library.

First, let's add the required dependency to our project:


The latest version of the library can be found here.

The StringUtils class has methods for replacing a substring of a String:

String master = "Hello World Baeldung!";
String target = "Baeldung";
String replacement = "Java";

String processed = StringUtils.replace(master, target, replacement);

There is an overloaded variant of the replace() that takes an integer max parameter, which determines the number of occurrences to replace. We can also use the replaceIgnoreCase() if case-sensitivity is not a concern:

String master2 = "Hello World Baeldung!";
String target2 = "baeldung";
String processed2 = StringUtils.replaceIgnoreCase(master2, target2, replacement);

5. Replacing Exact Words

In this last example, we'll learn how to replace an exact word inside a String.

The straightforward way to perform this replacement is using a regular expression with word boundaries.

The word boundary regular expression is \b. Enclosing the desired word inside this regular expression will only match exact occurrences.

First, let's see how to use this regular expression with the String API:

String sentence = "A car is not the same as a carriage, and some planes can carry cars inside them!";
String regexTarget = "\\bcar\\b";
String exactWordReplaced = sentence.replaceAll(regexTarget, "truck");

The exactWordReplaced string contains:

"A truck is not the same as a carriage, and some planes can carry cars inside them!"

Only the exact word will be replaced. Notice backward slash always needs to be escaped when working with regular expressions in Java.

An alternate way to do this replacement is using the RegExUtils class from the Apache Commons Library, which can be added as a dependency as we saw in the previous section:

String regexTarget = "\\bcar\\b";
String exactWordReplaced = RegExUtils.replaceAll(sentence, regexTarget, "truck");

While both methods will yield the same result, deciding which one should be used will depend on our specific scenario.

6. Conclusion

In conclusion, we've explored more than one way of removing and replacing a substring in Java. The best method to apply still largely depends on the current situation and context.

As usual, the complete source code is available over on Github.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


Generic footer banner
Comments are closed on this article!