Java 11新特性String类增强与HTTP Client

引言：Java 11的辉煌登场

各位Java爱好者，大家好！今天我们要一起探讨的是Java 11中两个非常重要的新特性：String类的增强和新的HttpClient。作为Java开发者，我们都知道，Java社区一直在不断地进化和发展，每一版的新特性都为我们带来了更多的工具和更强大的功能。Java 11也不例外，它不仅带来了性能上的提升，还为开发者提供了许多实用的新特性，尤其是对String类和HTTP客户端的改进。

Java 11发布于2018年9月，是Java长期支持（LTS）版本之一。LTS版本意味着它将得到更长时间的支持和更新，因此对于企业级应用来说尤为重要。Java 11在保持向后兼容性的同时，引入了许多现代化的功能，使得开发变得更加高效、简洁和安全。

在这篇文章中，我们将以轻松诙谐的方式，深入浅出地讲解Java 11中String类的增强和HttpClient的使用。我们会通过大量的代码示例和表格来帮助大家更好地理解这些新特性，并引用一些国外的技术文档来确保内容的权威性和准确性。希望通过这篇文章，大家能够掌握这些新特性，并在实际项目中灵活运用它们。

那么，让我们先从String类的增强开始吧！

Java 11中String类的增强

1. isBlank()方法

在Java 11之前，如果我们想检查一个字符串是否为空或只包含空白字符，通常会使用isEmpty()方法或者结合trim()和isEmpty()来实现。例如：

public boolean isBlank(String str) {
    return str == null || str.trim().isEmpty();
}

这种方式虽然可行，但显得有些繁琐。Java 11为我们提供了一个更加简洁的方法——isBlank()。这个方法直接判断字符串是否为空或只包含空白字符，大大简化了代码。下面是isBlank()的官方定义：

The isBlank() method returns true if the string is empty or contains only white space codepoints, otherwise it returns false.

来看一个简单的例子：

public class IsBlankExample {
    public static void main(String[] args) {
        String str1 = "";
        String str2 = "   ";
        String str3 = "Hello World";

        System.out.println(str1.isBlank()); // true
        System.out.println(str2.isBlank()); // true
        System.out.println(str3.isBlank()); // false
    }
}

通过isBlank()，我们可以轻松判断一个字符串是否为空或只包含空白字符，而不需要额外的逻辑处理。这不仅提高了代码的可读性，也减少了出错的可能性。

2. lines()方法

在处理文本文件时，我们经常需要将文件内容按行分割成多个字符串。在Java 11之前，我们通常会使用split()方法或者BufferedReader来实现这一功能。例如：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFileExample {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

这种方式虽然有效，但在某些情况下可能会显得过于复杂。Java 11引入了lines()方法，它可以将字符串按行分割成流（Stream），并且可以直接应用于文件读取等场景。下面是lines()的官方定义：

The lines() method splits this string around matches of the line terminators and returns a stream of lines.

来看一个使用lines()的例子：

import java.util.stream.Stream;

public class LinesExample {
    public static void main(String[] args) {
        String text = "Line 1nLine 2nLine 3";
        Stream<String> lines = text.lines();

        lines.forEach(System.out::println);
    }
}

输出结果：

Line 1
Line 2
Line 3

lines()方法不仅简化了代码，还利用了Java 8引入的流式编程模型，使得处理大规模文本数据变得更加高效和灵活。我们可以结合Stream API的其他操作（如filter()、map()等）来进一步处理文本数据。

3. strip()、stripLeading()和stripTrailing()方法

在处理字符串时，我们经常需要去除字符串两端的空白字符。在Java 11之前，我们通常会使用trim()方法来实现这一功能。然而，trim()只能去除ASCII空格（即' '），而对于其他类型的空白字符（如Unicode中的空白字符），trim()并不能完全处理。例如：

public class TrimExample {
    public static void main(String[] args) {
        String str = " u2007 Hello World u2007 ";
        System.out.println(str.trim()); // " Hello World "
    }
}

可以看到，trim()并没有完全去除字符串两端的空白字符。为了解决这个问题，Java 11引入了strip()、stripLeading()和stripTrailing()方法。这些方法可以去除所有类型的空白字符，包括Unicode中的空白字符。下面是它们的官方定义：

• strip(): Removes all leading and trailing white space from this string.
• stripLeading(): Removes all leading white space from this string.
• stripTrailing(): Removes all trailing white space from this string.

来看一个使用strip()的例子：

public class StripExample {
    public static void main(String[] args) {
        String str = " u2007 Hello World u2007 ";
        System.out.println(str.strip()); // "Hello World"
    }
}

strip()方法成功去除了字符串两端的所有空白字符，包括Unicode中的空白字符。此外，stripLeading()和stripTrailing()分别用于去除字符串开头和结尾的空白字符，提供了更细粒度的控制。

4. repeat()方法

在某些场景下，我们可能需要重复某个字符串多次。在Java 11之前，我们通常会使用循环来实现这一功能。例如：

public class RepeatExample {
    public static void main(String[] args) {
        String str = "Hello ";
        int count = 5;
        StringBuilder result = new StringBuilder();

        for (int i = 0; i < count; i++) {
            result.append(str);
        }

        System.out.println(result.toString());
    }
}

这种方式虽然可行，但显得有些冗长。Java 11引入了repeat()方法，它可以轻松地重复字符串指定的次数。下面是repeat()的官方定义：

The repeat() method returns a string whose value is the concatenation of this string repeated n times.

来看一个使用repeat()的例子：

public class RepeatExample {
    public static void main(String[] args) {
        String str = "Hello ";
        String result = str.repeat(5);

        System.out.println(result); // "Hello Hello Hello Hello Hello "
    }
}

repeat()方法不仅简化了代码，还提高了性能，因为它内部使用了更高效的算法来实现字符串的重复。

5. indent()方法

在处理多行文本时，我们有时需要对文本进行缩进操作。在Java 11之前，我们通常会使用字符串拼接或正则表达式来实现这一功能。例如：

public class IndentExample {
    public static void main(String[] args) {
        String text = "Line 1nLine 2nLine 3";
        String indentedText = text.replaceAll("(?m)^", "    ");
        System.out.println(indentedText);
    }
}

这种方式虽然有效，但在某些情况下可能会显得过于复杂。Java 11引入了indent()方法，它可以轻松地对字符串进行缩进操作。下面是indent()的官方定义：

The indent() method returns a string whose value is this string, with each line indented by the specified number of spaces.

来看一个使用indent()的例子：

public class IndentExample {
    public static void main(String[] args) {
        String text = "Line 1nLine 2nLine 3";
        String indentedText = text.indent(4);

        System.out.println(indentedText);
    }
}

输出结果：

    Line 1
    Line 2
    Line 3

indent()方法不仅可以对字符串进行正向缩进（增加空格），还可以进行负向缩进（减少空格）。如果传递的参数为负数，则会从每行的开头删除相应数量的空格。如果某一行的空格数量不足以删除，则该行不会发生变化。

6. transform()方法

在某些场景下，我们可能需要对字符串进行复杂的转换操作。在Java 11之前，我们通常会使用StringBuilder或其他辅助类来实现这一功能。例如：

public class TransformExample {
    public static void main(String[] args) {
        String str = "Hello World";
        StringBuilder result = new StringBuilder();

        for (char c : str.toCharArray()) {
            if (Character.isUpperCase(c)) {
                result.append(Character.toLowerCase(c));
            } else {
                result.append(Character.toUpperCase(c));
            }
        }

        System.out.println(result.toString()); // "hELLO wORLD"
    }
}

这种方式虽然可行，但在某些情况下可能会显得过于复杂。Java 11引入了transform()方法，它可以轻松地对字符串进行任意的转换操作。下面是transform()的官方定义：

The transform() method applies the given function to this string and returns the result.

来看一个使用transform()的例子：

import java.util.function.UnaryOperator;

public class TransformExample {
    public static void main(String[] args) {
        String str = "Hello World";
        UnaryOperator<String> toggleCase = s -> s.chars()
                .mapToObj(i -> Character.isUpperCase(i) ? Character.toLowerCase(i) : Character.toUpperCase(i))
                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
                .toString();

        String result = str.transform(toggleCase);

        System.out.println(result); // "hELLO wORLD"
    }
}

transform()方法允许我们传入一个函数，该函数会对字符串的每个字符进行处理，并返回处理后的结果。这种方式不仅简化了代码，还使得转换操作更加灵活和强大。

总结：String类增强的亮点

通过以上几个例子，我们可以看到，Java 11对String类的增强主要体现在以下几个方面：

1. 简化常用操作：isBlank()、lines()、strip()等方法使得常见的字符串操作更加简洁和直观。
2. 提高代码可读性：repeat()、indent()等方法使得代码更加易读，减少了不必要的复杂逻辑。
3. 增强灵活性：transform()方法提供了强大的字符串转换能力，使得我们可以轻松实现复杂的转换操作。
4. 提升性能：strip()、repeat()等方法内部使用了更高效的算法，提升了字符串处理的性能。

这些增强不仅让我们的代码更加简洁和优雅，还提高了开发效率和代码的可维护性。接下来，我们将继续探讨Java 11中另一个重要的新特性——HttpClient。

Java 11中的HttpClient：现代化的HTTP请求处理

在Java 11之前，处理HTTP请求的方式主要有两种：一种是使用HttpURLConnection，另一种是使用第三方库（如Apache HttpClient或OkHttp）。HttpURLConnection虽然内置在JDK中，但它存在一些问题，比如API设计不够友好、缺少对现代HTTP协议的支持（如HTTP/2）等。而第三方库虽然功能强大，但增加了项目的依赖，且不同库之间的API差异较大，给开发者带来了一定的学习成本。

为了解决这些问题，Java 11引入了一个全新的HttpClient API，它是JDK 9中引入的HttpClient的正式版本。HttpClient不仅提供了更加现代化的API设计，还支持HTTP/2、WebSocket等现代协议，使得处理HTTP请求变得更加简单和高效。

1. 创建HttpClient实例

要使用HttpClient，首先需要创建一个HttpClient实例。HttpClient可以通过HttpClient.newBuilder()方法来创建，并且可以根据需要进行配置。例如：

import java.net.http.HttpClient;

public class HttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)  // 设置HTTP版本
                .followRedirects(HttpClient.Redirect.NORMAL)  // 自动处理重定向
                .build();

        System.out.println("HttpClient created: " + client);
    }
}

在这个例子中，我们创建了一个支持HTTP/2并自动处理重定向的HttpClient实例。HttpClient的构建器模式使得我们可以灵活地配置各种选项，例如设置连接超时、启用SSL等。

2. 发送GET请求

HttpClient最常用的功能之一就是发送HTTP请求。我们可以使用send()或sendAsync()方法来发送同步或异步的HTTP请求。下面是一个发送GET请求的示例：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class GetRequestExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
                .GET()  // 默认是GET请求，可以省略
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Response Body: " + response.body());
    }
}

在这个例子中，我们发送了一个GET请求到https://jsonplaceholder.typicode.com/posts/1，并使用HttpResponse.BodyHandlers.ofString()来处理响应体。HttpResponse对象包含了响应的状态码、头信息和响应体，我们可以根据需要进行进一步处理。

3. 发送POST请求

除了GET请求，HttpClient还支持发送POST请求。我们可以使用HttpRequest.Builder来构建POST请求，并通过HttpRequest.BodyPublishers来设置请求体。下面是一个发送POST请求的示例：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.io.IOException;

public class PostRequestExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        String json = "{ "title": "foo", "body": "bar", "userId": 1 }";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
                .header("Content-Type", "application/json")  // 设置请求头
                .POST(BodyPublishers.ofString(json))  // 设置请求体
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Response Body: " + response.body());
    }
}

在这个例子中，我们发送了一个POST请求，并在请求体中传递了一个JSON字符串。BodyPublishers.ofString()方法用于将字符串转换为请求体。我们还可以使用BodyPublishers.ofByteArray()或BodyPublishers.ofInputStream()来处理二进制数据或流式数据。

4. 处理异步请求

HttpClient不仅支持同步请求，还支持异步请求。我们可以通过sendAsync()方法来发送异步请求，并使用CompletableFuture来处理响应。下面是一个发送异步GET请求的示例：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class AsyncRequestExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
                .build();

        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        future.thenApply(HttpResponse::body)
              .thenAccept(System.out::println)
              .join();
    }
}

在这个例子中，我们使用sendAsync()方法发送了一个异步GET请求，并使用CompletableFuture的链式调用来处理响应。thenApply()方法用于提取响应体，thenAccept()方法用于打印响应体。join()方法用于等待异步操作完成。

5. 支持HTTP/2

HttpClient的一个重要特性是它支持HTTP/2协议。HTTP/2相比HTTP/1.1具有更好的性能和更低的延迟，尤其是在处理多个并发请求时。要在HttpClient中启用HTTP/2，只需在创建HttpClient时指定HttpClient.Version.HTTP_2即可。例如：

import java.net.http.HttpClient;

public class Http2Example {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)  // 启用HTTP/2
                .build();

        System.out.println("HttpClient created with HTTP/2 support: " + client);
    }
}

通过启用HTTP/2，我们可以充分利用现代Web服务器的优势，提升应用程序的性能和响应速度。

6. WebSocket支持

除了HTTP请求，HttpClient还支持WebSocket协议。WebSocket是一种全双工通信协议，适用于实时数据传输场景。HttpClient提供了WebSocket.Builder类来创建WebSocket连接，并允许我们注册事件处理器来处理连接状态变化、消息接收等事件。下面是一个简单的WebSocket示例：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CompletionStage;

public class WebSocketExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        URI uri = URI.create("wss://echo.websocket.org");

        CompletionStage<WebSocket> wsFuture = client.newWebSocketBuilder()
                .buildAsync(uri, new WebSocket.Listener() {
                    @Override
                    public void onOpen(WebSocket webSocket) {
                        System.out.println("WebSocket connection opened");
                        webSocket.sendText("Hello, WebSocket!", true);
                    }

                    @Override
                    public void onText(WebSocket webSocket, CharSequence data, boolean last) {
                        System.out.println("Received message: " + data);
                        webSocket.close(WebSocket.NORMAL_CLOSURE, "Closing connection");
                    }

                    @Override
                    public void onClose(WebSocket webSocket, int statusCode, String reason) {
                        System.out.println("WebSocket connection closed: " + reason);
                    }
                });

        wsFuture.join();
    }
}

在这个例子中，我们创建了一个WebSocket连接，并注册了事件处理器来处理连接打开、消息接收和连接关闭等事件。onOpen()方法在连接建立时被调用，onText()方法在收到消息时被调用，onClose()方法在连接关闭时被调用。

总结：HttpClient的优势

通过以上几个例子，我们可以看到，Java 11中的HttpClient具有以下优势：

1. 现代化的API设计：HttpClient采用了更加直观和易用的API设计，使得发送HTTP请求变得更加简单。
2. 支持HTTP/2和WebSocket：HttpClient不仅支持HTTP/1.1，还支持HTTP/2和WebSocket，满足了现代Web开发的需求。
3. 异步请求支持：HttpClient提供了异步请求的能力，使得我们可以更高效地处理并发请求。
4. 内置支持：HttpClient是JDK的一部分，无需引入第三方依赖，减少了项目的复杂性。
5. 丰富的配置选项：HttpClient提供了多种配置选项，例如设置连接超时、启用SSL、处理重定向等，使得我们可以根据需要灵活地调整行为。

结语

通过本文的介绍，相信大家已经对Java 11中String类的增强和HttpClient有了更深入的了解。String类的增强使得字符串操作更加简洁和高效，而HttpClient则为我们提供了一个现代化的HTTP请求处理工具，支持HTTP/2、WebSocket等现代协议。这些新特性不仅提升了开发效率，还使得我们的代码更加优雅和可维护。

希望这篇文章能够帮助大家更好地掌握Java 11的新特性，并在实际项目中灵活运用它们。如果你有任何问题或建议，欢迎在评论区留言交流。感谢大家的阅读，祝大家 coding 快乐！