# Bài 9: Cải tiến về String (Java 11)

#### Mục tiêu

Bài viết này nhằm mục đích giúp bạn hiểu và sử dụng các cải tiến mới về String trong Java 11. Chúng ta sẽ xem xét các phương thức mới của lớp `String`, cách sử dụng chúng, các ví dụ thực tế và lợi ích mà chúng mang lại.

#### Nội dung

### 1\. Giới thiệu về các cải tiến String trong Java 11

#### 1.1 Mục đích của các cải tiến

* **Mục đích:** Cải tiến các thao tác với chuỗi ký tự (`String`) trong Java để làm cho mã nguồn ngắn gọn, dễ đọc và hiệu quả hơn.
    
* **Các phương thức mới:** `isBlank()`, `lines()`, `strip()`, `repeat()`, `stripLeading()`, `stripTrailing()`, `indent()`, và `transform()`.
    

#### 1.2 Lợi ích của các cải tiến

* **Đơn giản hóa các thao tác chuỗi:** Các phương thức mới giúp đơn giản hóa các thao tác thường gặp với chuỗi.
    
* **Tăng hiệu suất và khả năng đọc mã nguồn:** Các phương thức này giúp viết mã ngắn gọn và trực quan hơn, tăng khả năng đọc và bảo trì mã nguồn.
    
* **Giảm thiểu lỗi:** Cung cấp các phương thức tiện lợi giúp giảm thiểu lỗi trong xử lý chuỗi.
    

### 2\. Các phương thức mới trong lớp String

#### 2.1 isBlank()

* **Mục đích:** Kiểm tra xem một chuỗi có trống (chỉ chứa khoảng trắng) hay không.
    
* **Ví dụ:**
    
    ```java
    String str1 = "   ";
    String str2 = "Hello";
    
    System.out.println(str1.isBlank()); // Output: true
    System.out.println(str2.isBlank()); // Output: false
    ```
    

#### 2.2 lines()

* **Mục đích:** Tách chuỗi thành các dòng (dựa trên ký tự ngắt dòng) và trả về một `Stream` các dòng.
    
* **Ví dụ:**
    
    ```java
    String multilineStr = "Hello\nWorld\nJava 11";
    
    multilineStr.lines().forEach(System.out::println);
    // Output:
    // Hello
    // World
    // Java 11
    ```
    

#### 2.3 strip()

* **Mục đích:** Loại bỏ khoảng trắng ở đầu và cuối chuỗi, hỗ trợ tốt hơn `trim()` vì `strip()` xử lý cả các ký tự khoảng trắng Unicode.
    
* **Ví dụ:**
    
    ```java
    String str = "  Hello World  ";
    
    System.out.println(">" + str.strip() + "<"); // Output: >Hello World<
    ```
    

#### 2.4 stripLeading()

* **Mục đích:** Loại bỏ khoảng trắng ở đầu chuỗi.
    
* **Ví dụ:**
    
    ```java
    String str = "  Hello World  ";
    
    System.out.println(">" + str.stripLeading() + "<"); // Output: >Hello World  <
    ```
    

#### 2.5 stripTrailing()

* **Mục đích:** Loại bỏ khoảng trắng ở cuối chuỗi.
    
* **Ví dụ:**
    
    ```java
    String str = "  Hello World  ";
    
    System.out.println(">" + str.stripTrailing() + "<"); // Output: >  Hello World<
    ```
    

#### 2.6 repeat()

* **Mục đích:** Lặp lại chuỗi một số lần nhất định.
    
* **Ví dụ:**
    
    ```java
    String str = "Java";
    
    System.out.println(str.repeat(3)); // Output: JavaJavaJava
    ```
    

#### 2.7 indent()

* **Mục đích:** Thêm hoặc loại bỏ các khoảng trắng thụt đầu dòng cho mỗi dòng trong chuỗi.
    
* **Ví dụ:**
    
    ```java
    String str = "Hello\nWorld";
    
    System.out.println(str.indent(4));
    // Output:
    //     Hello
    //     World
    ```
    

#### 2.8 transform()

* **Mục đích:** Áp dụng một hàm chuyển đổi lên chuỗi và trả về kết quả.
    
* **Ví dụ:**
    
    ```java
    String str = "Hello";
    
    String result = str.transform(s -> s + " World");
    System.out.println(result); // Output: Hello World
    ```
    

### 3\. Ví dụ thực tế sử dụng các cải tiến về String

#### 3.1 Kiểm tra chuỗi trống

* **Ví dụ:**
    
    ```java
    String[] strings = {"", "   ", "\t", "Hello"};
    
    for (String str : strings) {
        if (str.isBlank()) {
            System.out.println("Blank string found");
        } else {
            System.out.println("Non-blank string: " + str);
        }
    }
    // Output:
    // Blank string found
    // Blank string found
    // Blank string found
    // Non-blank string: Hello
    ```
    

#### 3.2 Xử lý chuỗi nhiều dòng

* **Ví dụ:**
    
    ```java
    String multilineStr = "Java\nis\nawesome";
    
    long lineCount = multilineStr.lines().count();
    System.out.println("Number of lines: " + lineCount); // Output: Number of lines: 3
    ```
    

#### 3.3 Loại bỏ khoảng trắng không cần thiết

* **Ví dụ:**
    
    ```java
    String str = "\u2000Hello World\u2000";
    
    System.out.println("Original: >" + str + "<");
    System.out.println("Stripped: >" + str.strip() + "<");
    // Output:
    // Original: > Hello World <
    // Stripped: >Hello World<
    ```
    

#### 3.4 Lặp lại chuỗi để tạo mẫu

* **Ví dụ:**
    
    ```java
    String pattern = "*";
    
    System.out.println(pattern.repeat(10)); // Output: **********
    ```
    

#### 3.5 Thụt lề chuỗi

* **Ví dụ:**
    
    ```java
    String text = "Java\nProgramming";
    
    System.out.println(text.indent(2));
    // Output:
    //   Java
    //   Programming
    ```
    

### 4\. Thực hành với các bài toán thực tế

#### 4.1 Tạo khung văn bản

* **Bài toán:** Tạo khung cho một đoạn văn bản.
    
* **Giải pháp:**
    
    ```java
    String text = "Hello, World!";
    String border = "*".repeat(text.length() + 4);
    
    String framedText = border + "\n" +
                        "* " + text + " *\n" +
                        border;
    
    System.out.println(framedText);
    // Output:
    // ****************
    // * Hello, World! *
    // ****************
    ```
    

#### 4.2 Chuẩn hóa chuỗi đầu vào

* **Bài toán:** Chuẩn hóa một chuỗi đầu vào từ người dùng (loại bỏ khoảng trắng thừa và kiểm tra chuỗi trống).
    
* **Giải pháp:**
    
    ```java
    String input = "   Hello, Java 11!   ";
    
    if (input.isBlank()) {
        System.out.println("Input is blank");
    } else {
        String normalizedInput = input.strip();
        System.out.println("Normalized input: >" + normalizedInput + "<");
        // Output: Normalized input: >Hello, Java 11!<
    }
    ```
    

#### 4.3 Xử lý văn bản nhiều dòng

* **Bài toán:** Đếm số dòng trong một văn bản và in từng dòng có thụt lề.
    
* **Giải pháp:**
    
    ```java
    String document = "Java 11\nprovides new\nstring methods";
    
    long lineCount = document.lines().count();
    System.out.println("Number of lines: " + lineCount); // Output: Number of lines: 3
    
    document.lines().map(line -> "  " + line)
                    .forEach(System.out::println);
    // Output:
    //   Java 11
    //   provides new
    //   string methods
    ```
    

### Kết luận

Các cải tiến về String trong Java 11 mang lại nhiều phương thức tiện lợi và mạnh mẽ cho việc xử lý chuỗi. Những phương thức này giúp mã nguồn trở nên ngắn gọn, dễ đọc và bảo trì hơn. Hiểu và sử dụng thành thạo các phương thức mới này sẽ giúp bạn tận dụng tối đa sức mạnh của Java 11 trong các tác vụ liên quan đến chuỗi.

---