Java 15 New String and CharSequence Methods

Java 15 introduced several new methods in the String and CharSequence classes to enhance the manipulation of strings and character sequences. These methods provide more convenient ways to perform common operations and improve code readability and efficiency.

Key Points:

• Improved String Manipulation: New methods offer more straightforward and efficient ways to work with strings.
• Convenience: Simplifies common string operations, reducing the need for boilerplate code.
• Enhanced Readability: Improves code readability by providing more descriptive method names.

New Methods in Java 15

1. String::stripIndent

The stripIndent() method removes incidental whitespace from the beginning of each line in a string. It is particularly useful for dealing with multi-line strings and text blocks where indentation needs to be adjusted.

Syntax

String stripped = str.stripIndent();

• str: The string from which incidental whitespace is removed.
• stripped: The resulting string after removing incidental whitespace.

Example

public class StripIndentExample {
    public static void main(String[] args) {
        String textBlock = """
            \t\tThis is a text block
            \t\twith some indentation.
            \t\tEach line is indented.
            """;

        // Strip incidental whitespace from each line
        String strippedText = textBlock.stripIndent();

        System.out.println("Original Text Block:\n" + textBlock);
        System.out.println("Stripped Text Block:\n" + strippedText);
    }
}

Output:

Original Text Block:
		This is a text block
		with some indentation.
		Each line is indented.

Stripped Text Block:
		This is a text block
		with some indentation.
		Each line is indented.

Explanation:

• Whitespace Removal: The stripIndent() method removes common leading whitespace from each line, making the text block easier to read and manage.

2. String::translateEscapes

The translateEscapes() method converts escape sequences in a string into their corresponding characters. It is useful for processing strings with escape sequences, such as \n for new lines or \t for tabs.

Syntax

String translated = str.translateEscapes();

• str: The string containing escape sequences.
• translated: The resulting string after translating escape sequences.

Example

public class TranslateEscapesExample {
    public static void main(String[] args) {
        String escapedString = "Hello,\\nWorld!\\tJava 15";

        // Translate escape sequences into corresponding characters
        String translatedString = escapedString.translateEscapes();

        System.out.println("Escaped String: " + escapedString);
        System.out.println("Translated String: " + translatedString);
    }
}

Output:

Escaped String: Hello,\nWorld!\tJava 15
Translated String: Hello,
World!	Java 15

Explanation:

• Escape Sequence Translation: The translateEscapes() method converts escape sequences into their respective characters, such as \n to a newline and \t to a tab.

3. CharSequence::isEmpty

The isEmpty() method checks if a CharSequence is empty, i.e., if its length is zero. This method is now available on the CharSequence interface, making it easier to check for empty sequences without explicitly converting them to strings.

Syntax

boolean isEmpty = charSequence.isEmpty();

• charSequence: The CharSequence to be checked.
• isEmpty: A boolean value indicating whether the CharSequence is empty.

Example

public class CharSequenceIsEmptyExample {
    public static void main(String[] args) {
        CharSequence emptySequence = "";
        CharSequence nonEmptySequence = "Java 15";

        // Check if the CharSequences are empty
        boolean isEmpty1 = emptySequence.isEmpty();
        boolean isEmpty2 = nonEmptySequence.isEmpty();

        System.out.println("Is emptySequence empty? " + isEmpty1);
        System.out.println("Is nonEmptySequence empty? " + isEmpty2);
    }
}

Output:

Is emptySequence empty? true
Is nonEmptySequence empty? false

Explanation:

• Empty Check: The isEmpty() method on the CharSequence interface allows for straightforward checks for empty sequences, improving code readability and expressiveness.

4. String::formatted

The formatted() method provides a more readable way to format strings using placeholders, similar to the String.format() method. It allows for easier creation of formatted strings without needing to use the static format method.

Syntax

String formattedString = template.formatted(args...);

• template: The string template containing placeholders.
• args: The arguments to be inserted into the placeholders.
• formattedString: The resulting formatted string.

Example

public class FormattedExample {
    public static void main(String[] args) {
        String template = "Hello, %s! Welcome to Java %d.";
        
        // Format the string using the formatted() method
        String formattedString = template.formatted("Ananya", 15);

        System.out.println(formattedString);
    }
}

Output:

Hello, Ananya! Welcome to Java 15.

Explanation:

• String Formatting: The formatted() method provides a cleaner syntax for formatting strings, improving code readability.

Benefits of New String and CharSequence Methods

• Convenience: The new methods simplify common operations on strings and character sequences.
• Improved Readability: More descriptive method names and simpler syntax enhance code readability.
• Efficiency: Provides efficient ways to perform string manipulations without unnecessary conversions or boilerplate code.

Conclusion

Java 15 introduced several new methods in the String and CharSequence classes that enhance the manipulation of strings and character sequences. These methods provide more convenient ways to perform common operations and improve code readability and efficiency.

Summary:

• stripIndent(): Removes incidental whitespace from each line in a string.
• translateEscapes(): Converts escape sequences into their corresponding characters.
• isEmpty(): Checks if a CharSequence is empty.
• formatted(): Provides a more readable way to format strings using placeholders.

By leveraging these new methods, developers can write cleaner and more efficient Java code, improving the maintainability and readability of their applications.