A Complete Guide - Java Programming String Class and StringBuilder

Java Programming: String Class and StringBuilder

Introduction

Java provides powerful classes for handling text. Among them, the String class and the StringBuilder class play crucial roles.

• String: Immutable sequence of characters.
• StringBuilder: Mutable sequence of characters, offering better performance for scenarios involving frequent modification.

Table of Contents

1. Understanding Strings in Java
2. String Methods
3. Introduction to StringBuilder
4. StringBuilder Methods
5. Examples Using String and StringBuilder

1. Understanding Strings in Java

Strings in Java are sequences of characters. They are immutable, meaning once a string is created, it cannot be changed. Any modification of a string will result in the creation of a new string object.

Example to Create a String

public class StringExample {
    public static void main(String[] args) {
        // Creating a String using string literal
        String str1 = "Hello, World!";
        
        // Creating a String using the new keyword
        String str2 = new String("Hello, World!");
        
        // Printing both strings
        System.out.println("str1: " + str1);
        System.out.println("str2: " + str2);
    }
}

Output:

str1: Hello, World!
str2: Hello, World!

String Interning

Java automatically interns string literals. This means str1 and str2 in the example above are the same object if they contain the same value and are interned (though not always as with the new keyword).

2. String Methods

Common Methods on String Class

1. length(): Returns the number of characters in the string.
2. charAt(int index): Returns the character at the specified index.
3. substring(int beginIndex): Returns a new string that is a substring of this string.
4. indexOf(String str): Returns the index within this string of the first occurrence of the specified substring.
5. equals(Object obj): Compares this string to the specified object.
6. equalsIgnoreCase(String anotherString): Compares this string to another string, ignoring case considerations.
7. trim(): Returns a copy of the string, with leading and trailing whitespace omitted.
8. toUpperCase()/toLowerCase(): Converts all characters in the string to upper or lower case respectively.
9. concat(String str): Concatenates the specified string to the end of this string.
10. replace(char oldChar, char newChar): Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

Example to Use String Methods

public class StringMethodsExample {
    public static void main(String[] args) {
        String original = "Hello, Java!";
        
        // length() method
        System.out.println("Length: " + original.length());
        
        // charAt() method
        System.out.println("Character at index 7: " + original.charAt(7));
        
        // substring() method
        System.out.println("Substring from index 7: " + original.substring(7));
        
        // indexOf() method
        System.out.println("Index of 'Java': " + original.indexOf("Java"));
        
        // equals() and equalsIgnoreCase() methods
        System.out.println("Equals 'hello, java!': " + original.equals("hello, java!"));
        System.out.println("EqualsIgnoreCase 'hello, java!': " + original.equalsIgnoreCase("hello, java!"));
        
        // trim(), toUpperCase(), and toLowerCase() methods
        String spaceString = "   Hello, World   ";
        System.out.println("Original: " + spaceString);
        System.out.println("Trimmed: " + spaceString.trim());
        System.out.println("UpperCase: " + original.toUpperCase());
        System.out.println("LowerCase: " + original.toLowerCase());
        
        // concat() method
        System.out.println("Concatenated: " + original.concat(" Welcome!"));
        
        // replace() method
        System.out.println("Replaced: " + original.replace('J', 'K'));
    }
}

Output:

Length: 12
Character at index 7: J
Substring from index 7: Java!
Index of 'Java': 7
Equals 'hello, java!': false
EqualsIgnoreCase 'hello, java!': true
Original:    Hello, World   
Trimmed: Hello, World
UpperCase: HELLO, JAVA!
LowerCase: hello, java!
Concatenated: Hello, Java! Welcome!
Replaced: Hello, Kava!

3. Introduction to StringBuilder

StringBuilder is a mutable sequence of characters. This class is used when you need to modify the string frequently, as it avoids creating new objects upon each modification, thus improving performance.

Creating a StringBuilder

public class StringBuilderExample {
    public static void main(String[] args) {
        // Creating a StringBuilder object with an initial string
        StringBuilder sb = new StringBuilder("Hello, Java!");
        
        // Printing the original StringBuilder
        System.out.println("Original: " + sb);
    }
}

Output:

Original: Hello, Java!

4. StringBuilder Methods

Common Methods on StringBuilder Class

1. append(String str): Appends the specified string to this character sequence.
2. insert(int offset, String str): Inserts the string into this sequence.
3. delete(int start, int end): Removes the characters in a substring of this sequence.
4. replace(int start, int end, String str): Replaces the characters in a substring of this sequence with characters in the specified String.
5. reverse(): Causes this character sequence to be replaced by the reverse of the sequence.
6. toString(): Converts this StringBuilder to a String.

Example to Use StringBuilder Methods

public class StringBuilderMethodsExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, Java!");
        
        // append() method
        sb.append(" Welcome!");
        System.out.println("Append: " + sb);
        
        // insert() method
        sb.insert(13, " Beginners");
        System.out.println("Insert: " + sb);
        
        // delete() method
        sb.delete(7, 12);
        System.out.println("Delete: " + sb);
        
        // replace() method
        sb.replace(0, 5, "Hi");
        System.out.println("Replace: " + sb);
        
        // reverse() method
        sb.reverse();
        System.out.println("Reverse: " + sb);
        
        // toString() method to convert StringBuilder to String
        String result = sb.toString();
        System.out.println("toString(): " + result);
    }
}

Output:

Append: Hello, Java! Welcome!
Insert: Hello, Java Beginners! Welcome!
Delete: Hello Beginners! Welcome!
Replace: Hi Beginners! Welcome!
Reverse: !emoclew olleH nierebseuB
toString(): !emoclew olleH nierebseuB

5. Examples Using String and StringBuilder

Concatenation vs. StringBuilder Performance

Concatenating strings using the + operator creates many intermediate String objects, which can be inefficient. StringBuilder avoids this overhead.

Example: String Concatenation with +

public class StringConcatenationExample {
    public static void main(String[] args) {
        String str = "";
        for(int i = 0; i < 1000; i++) {
            str += i; // Creates a new String object each time
        }
        System.out.println(str);
    }
}

Example: StringBuilder for Fast Concatenation

public class StringBuilderConcatenationExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < 1000; i++) {
            sb.append(i); // No new object creation
        }
        System.out.println(sb.toString());
    }
}

Conclusion

• String: Use when the string contents are constant and you want to optimize for memory usage and immutability.
• StringBuilder: Use when you need to manipulate strings frequently and require better performance.

By mastering the String class and StringBuilder, you'll be well-equipped to handle textual data effectively in Java.