Replace in Java: Replace Characters or Strings Easily

How do you replace one or multiple characters in a Java string without modifying the original string?

Strings in Java are immutable, which means they cannot be changed once created. But Java provides built-in methods like replace() and replaceFirst() that let you generate a new string with the specified replacements applied. These methods are commonly used in data cleaning, formatting, or string manipulation tasks.

In this tutorial, you’ll learn how to use the replace() method in Java, its syntax, return value, and how it differs from replaceFirst(). We’ll also cover how to replace characters or substrings in Java, including multiple replacements, and explore exceptions (if any) that might occur while using these methods.

Want to master Java string manipulation and build cleaner, bug-free code? Explore upGrad’s Software Engineering Courses and learn Java hands-on with projects, mentorship, and job-ready skills.

Java String replace(): What It Is and How It Works

This tutorial focuses on the Java string.replace() method, where a new one can replace every occurrence of the old character. This method returns a string to replace each old character with a new char or CharSequence.

Since the launch of JDK 1.5, a new operation has been introduced in Java that allows you to replace an entire sequence of char values.

Common Exceptions While Using the replace() Method in Java

The replace() method has a specific feature where a null regular expression does not get accepted, this scenario is known as the NullPointerException.

Applications of the Java.String.replace() Operation

Java replace regex allows you to replace characters with a regular expression. The Java replace() method has several other functionalities, such as:

• Assists in reading data from files with comma-separated values, where you can replace the delimiters with a space using this method to split the words.
• Allows you to change and replace special characters for specific demands, like language and dialect. These replacements do not change the ulterior meaning of the word, it simply makes the string more understandable across the world.
• Helps with handling URLs in Java, where you can encode the string to replace the desired characters.

replace() Method Syntax in Java

The replace() method in Java has two different overloads:

1. replace(char oldChar, char newChar): This overload replaces all occurrences of the oldChar character with the newChar character in the string. The method returns a new string with the replacements.

Example Syntax:

String originalString = "Hello!";
String replacedString = originalString.replace('o', 'e');
System.out.println(replacedString); // Output: Helle!

In this example, the replace('o', 'e') call replaces all occurrences of the character 'o' with the character 'e' in the original string "Hello!", resulting in the replaced string "Helle!".

2. replace(CharSequence target, CharSequence replacement): This overload replaces all occurrences of the target sequence with the replacement sequence in the string. The target and replacement parameters can be either a String or a StringBuilder object. The method returns a new string with the replacements.

Example Syntax:

String originalString = "Hello!";
String replacedString = originalString.replace("Hello", "Hi");
System.out.println(replacedString); // Output: Hi!

In this example, the replace("Hello", "Hi") call replaces all occurrences of the substring "Hello" with the substring "Hi" in the original string "Hello!", resulting in the replaced string "Hi!".

replace() Return Value

The return value of the replace() method is a new string object that represents the original string with the modifications or replacements made. It does not modify the original string itself because strings in Java are immutable. Instead, the replace() method creates and returns a new string that reflects the modifications.

public class upGrad {
    public static void main(String[] args) {
        String originalString = "upGras";
        String replacedString = originalString.replace('s', 'd');

        System.out.println(originalString);  // Output: upGras
        System.out.println(replacedString);  // Output: upGrad
    }
}

In this example, the replace() method is called on the originalString object. The return value of the method is assigned to the replacedString variable. Notice that the originalString remains unchanged, while the replacedString contains the modified string with the replacements applied.

It's important to store and use the return value of the replace() method if you want to work with the modified string.

How to Use replaceFirst() in Java Strings

Similar to the Java.String.replace() method, this technique replaces the first substring of the string that has a match between the provided regular expression and the given replacement value.

Identical to the Java.String.replace() operation, this method also returns a resulting string.

Examples of String replace() Method in Java

public class upGrad {
    public static void main(String[] args) {
        // Example 1: Replacing a single character
        String originalString1 = "upGrad";
        String replacedString1 = originalString1.replace('u', 'U');
        System.out.println("Example 1:");
        System.out.println("Original string: " + originalString1);
        System.out.println("Replaced string: " + replacedString1);
        System.out.println();

        // Example 2: Replacing a substring
        String originalString2 = "upGrad";
        String replacedString2 = originalString2.replace("Grad", "Skills");
        System.out.println("Example 2:");
        System.out.println("Original string: " + originalString2);
        System.out.println("Replaced string: " + replacedString2);
        System.out.println();

        // Example 3: Replacing multiple characters
        String originalString3 = "upGrad";
        String replacedString3 = originalString3.replace("u", "U").replace("p", "P");
        System.out.println("Example 3:");
        System.out.println("Original string: " + originalString3);
        System.out.println("Replaced string: " + replacedString3);
        System.out.println();

        // Example 4: Replacing multiple characters using regex
        String originalString4 = "upGrad";
        String replacedString4 = originalString4.replaceAll("[aeiou]", "*");
        System.out.println("Example 4:");
        System.out.println("Original string: " + originalString4);
        System.out.println("Replaced string: " + replacedString4);
    }
}

Output:

The above program demonstrates various examples of using Java's replace() method to replace characters or substrings within a string. Let's go through each example in detail:

Example 1: Replacing a single character

In this example, the original string upGrad is assigned to the originalString1 variable. The replace() method is then used to replace the character 'u' with 'U', resulting in the modified string UpGrad. The original and replaced strings are printed using System.out.println().

Example 2: Replacing a substring

In this example, the original string upGrad is assigned to the originalString2 variable. The replace() method is used to replace the substring "Grad" with "Skills", resulting in the modified string upSkills. Like the previous example, original and replaced strings are printed using System.out.println().

Example 3: Replacing multiple characters

In this example, the original string upGrad is assigned to the originalString3 variable. Chaining multiple replace() methods is applied to replace the characters 'u' and 'p' with their uppercase counterparts, resulting in the modified string UpGrad. The original and replaced strings are then printed using System.out.println().

Example 4: Replacing multiple characters using regex

In this example, the original string upGrad is assigned to the originalString4 variable. The replaceAll() method is used with a regular expression [aeiou] to match and replace all vowels with an asterisk (*), resulting in the modified string *pGr*d. Finally, the original and replaced strings are printed using System.out.println().

Understanding the replaceFirst() Method in Java

public class upGrad {
    public static void main(String[] args) {
      // Replacing the first occurrence of a substring
        String originalString5 = "upGrad";
        String replacedString5 = originalString5.replaceFirst("a", "A");
        System.out.println("replaceFirst Example:");
        System.out.println("Original string: " + originalString5);
        System.out.println("Replaced string: " + replacedString5);
    }
}

This program begins by defining a class named upGrad. Inside the main method, a string variable originalString5 is declared and assigned the value "upGrad". This variable represents the original string on which the replacement operation will be performed.

The replaceFirst() method is then used on originalString5 to replace the first occurrence of the substring "a" with the character "A". The resulting replaced string is stored in the variable replacedString5.

Finally, to display the output, the program uses System.out.println() to print the heading "replaceFirst Example:". It then prints the original and replaced strings by concatenating them with appropriate messages.

Handling Exceptions with the replace() Method in Java

The replace() method in Java does not throw any exceptions on its own. It is a safe operation that performs string replacement without raising any exceptions. Therefore, we do not need to handle specific exceptions using the replace() method.

However, it is important to note that the replace() method creates a new string with the replaced characters and returns it. The original string remains unchanged. So if we wish to store the result of the replace() operation, we must assign it to a variable or use it in some way.

Here is an example:

In the above example, the replace() method is used to replace the substring "World" with "upGrad". The original string remains unchanged, and the replaced string is stored in the replacedString variable.

Code:

public class upGrad {
    public static void main(String[] args) {
        String originalString = "Hello, World!";
        String replacedString = originalString.replace("World", "upGrad");


        System.out.println("Original string: " + originalString);
        System.out.println("Replaced string: " + replacedString);
    }
}

Conclusion

There are three methods of replacing a character in String Class Java, namely:

• replace()
• replaceAll()
• replaceFirst()

This tutorial discussed changing characters in Java using the replace() method. You can improve your knowledge of different Java concepts by checking out similar tutorials. If you are keenly interested in joining an educational journey on Java, you can go through the courses available on upGrad that will assist you in refining your Java skills.

FAQs

1. How does the replace() method work in Java?

The replace() method in Java returns a new string by replacing all occurrences of a specified character or sequence with another. It does not modify the original string, as Java strings are immutable.

2. How to replace a character in a string in Java?

To replace a character in a string in Java, use string.replace('oldChar', 'newChar'). It returns a new string where every instance of the old character is replaced with the new one.

3. How to replace multiple characters in a string in Java?

To replace multiple characters in a string in Java, chain multiple replace() calls or use regular expressions with replaceAll() if you're targeting patterns or groups of characters.

4. Can we change a string value in Java directly?

No, Java strings are immutable, so you cannot change the original value. Instead, any method like replace() returns a new modified string, leaving the original unchanged.

5. What is the syntax of replace() in Java?

The syntax of the replace method in Java is:

string.replace(char oldChar, char newChar) or

string.replace(CharSequence target, CharSequence replacement).

It returns a new string with the specified replacement applied.

6. What does the replace() method return in Java?

The replace() method returns a new string with characters or substrings replaced as specified. It does not throw an exception if the match isn't found—it simply returns the original string unchanged.

7. What is the difference between replace() and replaceFirst() in Java?

replace() replaces all occurrences, while replaceFirst() replaces only the first matching substring. Both return new strings, making them safe for chaining or complex manipulations.

8. Can you replace characters in Java without using replace()?

Yes, you can use loops or StringBuilder to manually replace characters in Java. However, using replace() or replaceFirst() is more efficient and readable for most string replacement tasks.

9. What are some examples of using replace in Java?

An example:

"hello".replace('l', 'x') returns "hexxo".

Or,

"apple banana".replace("a", "*") replaces all 'a' characters. These examples show how replace in Java is used in real applications.

10. Are there any exceptions with the replace() method in Java?

No, the replace() method does not throw an exception even if the target character or string is not found. It simply returns the original string if there’s nothing to replace.

11. How to replace a character in Java using object replacement?

You can’t directly use object replacement for single characters, but for full substrings or sequences (as CharSequence), you can use replace() to substitute matching parts of the string with the desired object’s string value.

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz