Java版本怎么选以及JDK各版本特性对比与实战建议

// 传统方式
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

// Lambda方式
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());

List<String> result = list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plusWeeks(1);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .header("Accept", "application/json")
    .build();

// 同步请求
HttpResponse<String> response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

// 异步请求
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

String str = "  Hello World  \n";
boolean isBlank = str.isBlank(); // false
String stripped = str.strip();   // "Hello World"
List<String> lines = str.lines().collect(Collectors.toList());

public sealed class Shape permits Circle, Rectangle, Triangle {
    // 共同方法
}

public final class Circle extends Shape {
    private double radius;
}

// 传统方式
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// JDK 17方式
if (obj instanceof String s) {
    System.out.println(s.length());
}

String result = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY -> "Weekday";
    case THURSDAY, FRIDAY -> "Almost weekend";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Unknown";
};

// 创建并启动虚拟线程
Thread.startVirtualThread(() -> {
    try {
        // 执行异步任务
        Thread.sleep(Duration.ofSeconds(1));
        System.out.println("Virtual thread completed");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// 使用ExecutorService批量创建虚拟线程
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "Task " + Thread.currentThread().getName();
        });
    }
}

// 简洁的数据类定义
public record Person(String name, int age) {
    // 可以添加额外方法
    public boolean isAdult() {
        return age >= 18;
    }
}

// 使用记录类
Person person = new Person("John", 30);
System.out.println(person.name()); // 自动生成的访问方法

String formatted = switch (obj) {
    case Integer i -> String.format("Integer: %d", i);
    case Long l    -> String.format("Long: %d", l);
    case Double d  -> String.format("Double: %.2f", d);
    case String s  -> String.format("String: %s", s);
    default        -> obj.toString();
};

// 定义作用域值
private static final ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();

// 设置并使用作用域值
ScopedValue.where(USER_CONTEXT, new UserContext("admin"))
    .run(() -> {
        // 在作用域内访问用户上下文
        UserContext context = USER_CONTEXT.get();
        processRequest(context);
    });

// 使用结构化并发处理多个任务
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> userInfo = scope.fork(() -> fetchUserInfo(userId));
    Future<List<Order>> orders = scope.fork(() -> fetchOrders(userId));
    
    scope.join();        // 等待所有任务完成
    scope.throwIfFailed(); // 传播任何异常
    
    // 组合结果
    processData(userInfo.resultNow(), orders.resultNow());
}

// 使用结构化并发处理多个任务
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> userInfo = scope.fork(() -> fetchUserInfo(userId));
    Future<List<Order>> orders = scope.fork(() -> fetchOrders(userId));    

    scope.join();        // 等待所有任务完成
    scope.throwIfFailed(); // 传播任何异常    

    // 安全地获取结果并处理
    String userData = userInfo.resultNow();
    List<Order> orderList = orders.resultNow();
    processUserData(userData, orderList);
}

// 超时控制示例
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<Data> data = scope.fork(() -> fetchDataFromRemote());    

    // 设置超时
    if (!scope.joinUntil(Instant.now().plusSeconds(5))) {
        scope.cancel(); // 超时取消所有任务
        throw new TimeoutException("Data fetching timed out");
    }
    return data.resultNow();
}

// 定义区域局部变量
private static final ZonedLocal<UserContext> USER_CONTEXT = ZonedLocal.newInstance();

// 设置并在作用域内使用
ZonedLocal.where(USER_CONTEXT, new UserContext("admin", "system")).run(() -> {
        // 在同一线程内访问上下文
        processRequest();
        // 在虚拟线程中也能访问相同的上下文
        Thread.startVirtualThread(() -> {
            UserContext context = USER_CONTEXT.get();
            logUserActivity(context.username());
        });
    });

// 方法内部访问
void processRequest() {
    UserContext context = USER_CONTEXT.get();
    System.out.println("Processing request for: " + context.username());
}

// 原始类型的instanceof模式匹配
Object value = getSomeValue();
if (value instanceof int i) {
    System.out.println("Integer value: " + i);
} else if (value instanceof long l) {
    System.out.println("Long value: " + l);
} else if (value instanceof double d) {
    System.out.println("Double value: " + d);
}

// switch语句中使用原始类型
String result = switch (value) {
    case int i when i > 0 -> String.format("Positive integer: %d", i);
    case int i when i < 0 -> String.format("Negative integer: %d", i);
    case int i -> "Zero";
    case double d -> String.format("Double: %.2f", d);
    case String s -> "String: " + s;
    default -> "Unknown type";
};

// 使用向量API进行并行数值计算
FloatVector v1 = FloatVector.fromArray(FloatVector.SPECIES_256, new float[]{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f}, 0);
FloatVector v2 = FloatVector.fromArray(FloatVector.SPECIES_256, new float[]{8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f}, 0);

// 执行向量运算
FloatVector sum = v1.add(v2);
FloatVector product = v1.mul(v2);
FloatVector max = v1.max(v2);

// 将结果存储回数组
float[] result = new float[8];
sum.intoArray(result, 0);

// 计算数组元素的平方和
float[] data = getLargeArray();
float sumOfSquares = 0.0f;

// 向量处理大块数据
int vectorSize = FloatVector.SPECIES_PREFERRED.length();
int i = 0;
for (; i <= data.length - vectorSize; i += vectorSize) {
    FloatVector vec = FloatVector.fromArray(FloatVector.SPECIES_PREFERRED, data, i);
    sumOfSquares += vec.mul(vec).reduceLanes(VectorOperators.ADD);
}

// 处理剩余元素
for (; i < data.length; i++) {
    sumOfSquares += data[i] * data[i];
}

// 读取PEM格式的私钥
try (PemReader reader = new PemReader(new FileReader("private-key.pem"))) {
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    PrivateKey privateKey = (PrivateKey) reader.readPrivateKey();    

    // 使用私钥进行签名
    Signature signature = Signature.getInstance("SHA256withRSA");
    signature.initSign(privateKey);
    signature.update(data);
    byte[] signedData = signature.sign();
}

// 写入PEM格式的证书
try (PemWriter writer = new PemWriter(new FileWriter("certificate.pem"))) {
    Certificate certificate = getCertificate();
    writer.writeCertificate(certificate);
}