Home » Learning » Java » Lesson 13: New String Methods in Java 11+ (strip(), lines(), repeat())

JavaLearning

Lesson 13: New String Methods in Java 11+ (strip(), lines(), repeat())

javasleep

March 13, 2025

10 Views

SaveSavedRemoved 0

Java 11 introduced new methods for the String class, making it easier to handle whitespace, multi-line text, and string repetition.

1. strip(), stripLeading(), stripTrailing() (Better Whitespace Handling)

🔹 Before Java 11, trim() was used to remove spaces, but it only removed ASCII spaces (U+0020), not Unicode spaces.
🔹 Java 11 introduced strip(), which removes all leading and trailing Unicode whitespace.

📌 Example 1: Difference Between trim() and strip()

public class Main {
    public static void main(String[] args) {
        String s1 = "   Hello   ";
        String s2 = "\u2003Hello\u2003"; // Unicode whitespace

        System.out.println("Trim: [" + s2.trim() + "]");  // Doesn't remove Unicode spaces
        System.out.println("Strip: [" + s2.strip() + "]"); // ✅ Removes Unicode spaces
    }
}

✅ Output:

Trim: [ Hello ]
Strip: [Hello]

✔ strip() removes Unicode whitespace, unlike trim().

📌 Example 2: stripLeading() and stripTrailing()

public class Main {
    public static void main(String[] args) {
        String text = "   Java 11   ";

        System.out.println("Strip Leading: [" + text.stripLeading() + "]");
        System.out.println("Strip Trailing: [" + text.stripTrailing() + "]");
    }
}

✅ Output:

Strip Leading: [Java 11   ]
Strip Trailing: [   Java 11]

✔ More control over whitespace removal!

2. lines() – Splitting Multi-line Strings into a Stream

🔹 Before Java 11, splitting multi-line text required manually handling \n.
🔹 lines() simplifies this by converting a multi-line string into a Stream<String>.

📌 Example: Using lines() to Process Multi-Line Text

import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        String text = "Java 11\nNew Features\nImproved Performance";

        text.lines()
            .map(String::toUpperCase)  // Convert each line to uppercase
            .forEach(System.out::println);
    }
}

✅ Output:

JAVA 11
NEW FEATURES
IMPROVED PERFORMANCE

✔ lines() splits the string correctly without manually handling \n.

3. repeat(int n) – Repeat Strings Easily

🔹 Before Java 11, repeating a string required loops or StringBuilder.
🔹 repeat(n) simplifies this by repeating a string n times.

📌 Example: Using repeat()

public class Main {
    public static void main(String[] args) {
        String star = "*";

        System.out.println(star.repeat(5)); // Prints ***** 
    }
}

✅ Output:

*****

✔ Simpler than using loops!

🔄 Summary of Java 11+ String Methods

Lesson Reflection

1. Why is strip() better than trim() for removing whitespace?
2. How does lines() make multi-line text processing easier?
3. Can you think of a scenario where repeat() would be useful?

Answers to Reflection Questions on Java 11+ String Methods

1️⃣ Why is strip() better than trim() for removing whitespace?

✅ strip() handles Unicode whitespace, while trim() does not.

• trim() only removes ASCII space (U+0020).
• strip() removes all Unicode whitespace characters (like \u2003 – an invisible space).

📌 Example: Difference Between trim() and strip()

public class Main {
    public static void main(String[] args) {
        String unicodeSpace = "\u2003Hello\u2003"; // Unicode whitespace around "Hello"

        System.out.println("Trim: [" + unicodeSpace.trim() + "]");  // ❌ Doesn't remove Unicode spaces
        System.out.println("Strip: [" + unicodeSpace.strip() + "]"); // ✅ Removes Unicode spaces
    }
}

✅ Output:

Trim: [ Hello ]  // ❌ Unicode spaces remain
Strip: [Hello]    // ✅ Unicode spaces removed

✔ strip() is more powerful than trim() because it handles ALL whitespace characters.

2️⃣ How does lines() make multi-line text processing easier?

✅ lines() splits multi-line strings into a Stream<String>, allowing functional processing.

• Before Java 11, we had to manually split by \n and handle edge cases.
• Now, lines() does the work automatically and ignores empty trailing lines.

📌 Example: Processing Multi-Line Text with lines()

import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        String text = "Java 11\nNew Features\nBetter Performance";

        text.lines()
            .map(String::toUpperCase)  // Convert each line to uppercase
            .forEach(System.out::println);
    }
}

✅ Output:

JAVA 11
NEW FEATURES
BETTER PERFORMANCE

✔ No need to manually split and loop over lines!

3️⃣ Can you think of a scenario where repeat() would be useful?

🚀 Yes! repeat(n) is useful when generating formatted output.

✅ Use Case 1: Creating a Separator Line for Console Output

public class Main {
    public static void main(String[] args) {
        System.out.println("-".repeat(50)); // Prints a 50-character separator line
    }
}

✅ Output:

--------------------------------------------------

✔ This avoids loops or StringBuilder just to repeat characters.

✅ Use Case 2: Generating Test Data

public class Main {
    public static void main(String[] args) {
        var sampleData = "ABC".repeat(5); // Repeats "ABC" 5 times
        System.out.println(sampleData);
    }
}

✅ Output:

ABCABCABCABCABC

✔ Great for quickly generating repeated patterns in testing.

🔍 Key Takeaways

✔ strip() is better than trim() because it removes all Unicode whitespace.
✔ lines() simplifies multi-line text processing using Stream<String>.
✔ repeat(n) eliminates the need for loops when generating repeated strings.

The next Java 11+ feature: New File Methods (readString(), writeString())? 😊🚀