// 傳統(tǒng)方式
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;
}

// 傳統(tǒng)方式
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";
};

// 創(chuàng)建并啟動虛擬線程
Thread.startVirtualThread(() -> {
    try {
        // 執(zhí)行異步任務
        Thread.sleep(Duration.ofSeconds(1));
        System.out.println("Virtual thread completed");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// 使用ExecutorService批量創(chuàng)建虛擬線程
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "Task " + Thread.currentThread().getName();
        });
    }
}

// 簡潔的數(shù)據(jù)類定義
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);
    });

// 使用結構化并發(fā)處理多個任務
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());
}

// 使用結構化并發(fā)處理多個任務
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();
}

// 定義區(qū)域局部變量
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進行并行數(shù)值計算
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);

// 執(zhí)行向量運算
FloatVector sum = v1.add(v2);
FloatVector product = v1.mul(v2);
FloatVector max = v1.max(v2);

// 將結果存儲回數(shù)組
float[] result = new float[8];
sum.intoArray(result, 0);

// 計算數(shù)組元素的平方和
float[] data = getLargeArray();
float sumOfSquares = 0.0f;

// 向量處理大塊數(shù)據(jù)
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);
}