Examples of 4 methods of string replacement in Java

introduction

In Java programming, string substitution is a common operation to modify specific substrings in strings. Java provides a variety of methods to implement string replacement, each method has its own characteristics and applicable scenarios.

1. ()

()Methods are used to replace all matches in a string. This method accepts two parameters: the first parameter is the substring to be replaced, and the second parameter is the substring after being replaced.

1.1 Basic usage

public class ReplaceExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        String replaced = ("World", "Java");
        (replaced);  // Output: Hello, Java!    }
}

1.2 Advantages

Simple and easy to use: Concise syntax, easy to understand and use.
Global replacement: Automatically replace all matching substrings.

1.3 Disadvantages

Performance issues: For large amounts of data or frequent calls, performance may be degraded.
Regular expressions are not supported: Only simple substring replacement can be performed, regular expressions cannot be used.

2. ()

()Methods use regular expressions for global substitution. This method accepts two parameters: the first parameter is a regular expression, and the second parameter is a substring after replacement.

2.1 Basic usage

public class ReplaceAllExample {
    public static void main(String[] args) {
        String original = "Hello, World! Welcome to the World of Java.";
        String replaced = ("World", "Java");
        (replaced);  // Output: Hello, Java! Welcome to the Java of Java.    }
}

2.2 Advantages

Support regular expressions: Complex regular expressions can be used for matching and replacement.
Global replacement: Automatically replace all matching substrings.

2.3 Disadvantages

Performance issues: Matching and substitution of regular expressions may be more time-consuming than simple substring replacement.
Complexity: The writing and debugging of regular expressions may be more complicated.

3. ()

()Methods use regular expressions for first match replacement. This method accepts two parameters: the first parameter is a regular expression, and the second parameter is a substring after replacement.

3.1 Basic usage

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "Hello, World! Welcome to the World of Java.";
        String replaced = ("World", "Java");
        (replaced);  // Output: Hello, Java! Welcome to the World of Java.    }
}

3.2 Advantages

Support regular expressions: Complex regular expressions can be used for matching and replacement.
Single replacement: Replace only the first matched substring.

3.3 Disadvantages

Performance issues: Matching and substitution of regular expressions may be more time-consuming than simple substring replacement.
Complexity: The writing and debugging of regular expressions may be more complicated.

4. ()

()Method is used to replace characters within a specified range. This method accepts three parameters: the start index, the end index (not included), and the replaced substring.

4.1 Basic usage

public class StringBuilderReplaceExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        (7, 12, "Java");
        (());  // Output: Hello, Java!    }
}

4.2 Advantages

Variability：StringBuilderis mutable and suitable for scenarios where strings need to be modified multiple times.
Performance optimization: For a large number of modification operations,StringBuilderThe performance is better thanString。

4.3 Disadvantages

Index calculation: It is necessary to manually calculate the start and end index, which is prone to errors.
Regular expressions are not supported: Only simple substring replacement can be performed, regular expressions cannot be used.

Appendix: Use regular expressions

String replacement in Java can be usedreplaceAll()andreplaceFirst()method.replaceAll()The method replaces all matching substrings, andreplaceFirst()The method will only replace the first matching substring.

Here is an example of replacing a string with a regular expression:

import ;
import ;

public class Main {
    public static void main(String[] args) {
        String originalString = "Hello, world!";
        String pattern = "world";
        String replacement = "Java";

        // Replace string with regular expression        String resultString = (pattern, replacement);

        ("Raw String: " + originalString);
        ("Replaced string: " + resultString);
    }
}

Summarize

Java provides a variety of methods for string replacement, each method has its own characteristics and applicable scenarios:

(): Suitable for simple global substring replacement.

(): Applicable to global substitutions that require the use of regular expressions.

(): Suitable for first match replacements that require regular expressions to be used.

(): Suitable for scenarios where string modifications need to be made multiple times and high performance requirements.

Choosing the appropriate method depends on specific requirements, such as whether regular expressions are required, range of replacements, and performance requirements.

This is the end of this article about 4 methods of string replacement in Java. For more related contents of Java string replacement, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!