Java StringBuilder delete() Method

The StringBuilder.delete() method in Java is used to remove a sequence of characters from a StringBuilder object. This guide will cover the method's usage, explain how it works, and provide examples to demonstrate its functionality. We will also cover a real-world use case to show how StringBuilder.delete() can be used effectively.

Table of Contents

1. Introduction
2. delete Method Syntax
3. Examples
   • Removing a Substring from a StringBuilder
   • Handling Index Out of Bounds
4. Real-World Use Case
   • Example: Removing a Middle Name from a Full Name
5. Conclusion

Introduction

The StringBuilder.delete() method is a member of the StringBuilder class in Java. It allows you to remove a sequence of characters from a StringBuilder object, specified by a starting and ending index. This method is useful when you need to modify a string by removing specific substrings.

delete Method Syntax

The syntax for the delete method is as follows:

public StringBuilder delete(int start, int end)

• Parameters:
  • start: The beginning index, inclusive.
  • end: The ending index, exclusive.
• Returns: A reference to the same StringBuilder object, with the characters in the specified range removed.

Examples

Removing a Substring from a StringBuilder

The delete method can be used to remove a substring from a StringBuilder object.

Example

public class DeleteExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, world!");

        // Removing the substring ", world"
        sb.delete(5, 12);

        // Printing the modified StringBuilder
        System.out.println(sb.toString());
    }
}

Output:

Hello!

Handling Index Out of Bounds

If the specified indices are out of bounds (i.e., less than 0 or greater than the length of the StringBuilder), the delete method throws a StringIndexOutOfBoundsException.

Example

public class IndexOutOfBoundsExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, world!");

        try {
            // Attempting to remove a substring with invalid indices
            sb.delete(5, 20);
            System.out.println(sb.toString());
        } catch (StringIndexOutOfBoundsException e) {
            System.out.println("Index is out of bounds: " + e.getMessage());
        }
    }
}

Output:

Index is out of bounds: start 5, end 20, length 13

Real-World Use Case

Example: Removing a Middle Name from a Full Name

A common real-world use case for StringBuilder.delete() is removing a middle name from a full name.

Example

public class RemoveMiddleName {
    public static void main(String[] args) {
        StringBuilder fullName = new StringBuilder("Amit Kumar Sharma");

        // Removing the middle name "Kumar"
        int start = fullName.indexOf("Kumar");
        int end = start + "Kumar".length() + 1; // +1 to remove the trailing space
        fullName.delete(start, end);

        // Printing the modified full name
        System.out.println("Full Name without middle name: " + fullName.toString());
    }
}

Output:

Full Name without middle name: Amit Sharma

In this example, StringBuilder.delete() is used to remove a middle name from a full name, leaving only the first and last names.

Conclusion

The StringBuilder.delete() method in Java provides a way to remove a sequence of characters from a StringBuilder object. By understanding how to use this method, you can efficiently modify strings in your Java applications. The method allows you to perform various substring deletion operations, making it a versatile tool for string manipulation in various scenarios.