// 效能比較（以 GC 暫停時間為例）

Java 8 (Parallel GC)：     平均暫停 200-500ms
Java 11 (G1 GC)：          平均暫停 50-200ms  
Java 17 (ZGC)：            平均暫停 < 10ms
Java 21 (Generational ZGC)：平均暫停 < 1ms

# 使用 GraalVM 建立原生映像
native-image -jar myapp.jar

# 結果對比
# JAR 啟動：2-5 秒
# Native Image 啟動：< 50 毫秒

// Java 7 寫法：匿名內部類別
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按鈕被點擊");
    }
});

// Java 8 寫法：Lambda Expression
button.addActionListener(e -> System.out.println("按鈕被點擊"));

// Lambda 語法結構
// (參數列表) -> { 方法主體 }

// 1. 無參數
Runnable r = () -> System.out.println("Hello");

// 2. 單一參數（可省略括號）
Consumer<String> c = s -> System.out.println(s);

// 3. 多參數
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

// 4. 多行語句（需要大括號和 return）
BiFunction<Integer, Integer, Integer> calculate = (a, b) -> {
    int result = a + b;
    System.out.println("計算結果：" + result);
    return result;
};

// 5. 明確指定參數型別
BiFunction<String, String, String> concat = 
    (String a, String b) -> a + b;

// 方法參考是 Lambda 的簡化寫法

// 1. 靜態方法參考
// Lambda: s -> Integer.parseInt(s)
Function<String, Integer> parser = Integer::parseInt;

// 2. 實例方法參考（特定物件）
// Lambda: s -> System.out.println(s)
Consumer<String> printer = System.out::println;

// 3. 實例方法參考（任意物件）
// Lambda: s -> s.toUpperCase()
Function<String, String> upper = String::toUpperCase;

// 4. 建構子參考
// Lambda: () -> new ArrayList<>()
Supplier<List<String>> listFactory = ArrayList::new;

// Java 7 寫法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filtered = new ArrayList<>();
for (String name : names) {
    if (name.length() > 3) {
        filtered.add(name.toUpperCase());
    }
}
Collections.sort(filtered);

// Java 8 寫法
List<String> result = names.stream()
    .filter(name -> name.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

// 自定義 Functional Interface
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
    
    // 可以有 default 方法
    default void printResult(int a, int b) {
        System.out.println("結果：" + calculate(a, b));
    }
    
    // 可以有 static 方法
    static Calculator getAdder() {
        return (a, b) -> a + b;
    }
}

// 使用
Calculator adder = (a, b) -> a + b;
Calculator multiplier = (a, b) -> a * b;

// 實務範例：組合使用
public class FunctionalInterfaceDemo {
    
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "", "Charlie", null);
        
        // Predicate 組合
        Predicate<String> notNull = Objects::nonNull;
        Predicate<String> notEmpty = s -> !s.isEmpty();
        Predicate<String> valid = notNull.and(notEmpty);
        
        // Function 組合
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, String> process = trim.andThen(upper);
        
        // 完整處理流程
        List<String> result = names.stream()
            .filter(valid)
            .map(process)
            .collect(Collectors.toList());
        
        System.out.println(result); // [ALICE, BOB, CHARLIE]
    }
}

List<Employee> employees = getEmployees();

// 1. filter - 過濾
employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .forEach(System.out::println);

// 2. map - 轉換
List<String> names = employees.stream()
    .map(Employee::getName)
    .collect(Collectors.toList());

// 3. flatMap - 扁平化
List<String> allSkills = employees.stream()
    .flatMap(e -> e.getSkills().stream())
    .distinct()
    .collect(Collectors.toList());

// 4. sorted - 排序
employees.stream()
    .sorted(Comparator.comparing(Employee::getSalary).reversed())
    .forEach(System.out::println);

// 5. distinct - 去重
List<String> uniqueDepts = employees.stream()
    .map(Employee::getDepartment)
    .distinct()
    .collect(Collectors.toList());

// 6. limit / skip - 分頁
employees.stream()
    .skip(10)    // 跳過前 10 筆
    .limit(10)   // 取 10 筆
    .forEach(System.out::println);

// 7. peek - 除錯用
employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .peek(e -> System.out.println("過濾後：" + e.getName()))
    .map(Employee::getName)
    .collect(Collectors.toList());

// 1. collect - 收集結果
List<Employee> list = stream.collect(Collectors.toList());
Set<Employee> set = stream.collect(Collectors.toSet());
Map<String, Employee> map = stream.collect(
    Collectors.toMap(Employee::getId, Function.identity())
);

// 2. reduce - 歸納
int totalSalary = employees.stream()
    .mapToInt(Employee::getSalary)
    .reduce(0, Integer::sum);

// 3. 統計操作
long count = employees.stream().count();
Optional<Employee> max = employees.stream()
    .max(Comparator.comparing(Employee::getSalary));
    
// 4. 匹配操作
boolean anyMatch = employees.stream()
    .anyMatch(e -> e.getSalary() > 100000);
boolean allMatch = employees.stream()
    .allMatch(e -> e.getAge() >= 18);
boolean noneMatch = employees.stream()
    .noneMatch(e -> e.getName() == null);

// 5. 查找操作
Optional<Employee> first = employees.stream()
    .filter(e -> e.getDepartment().equals("IT"))
    .findFirst();

// 1. 分組
Map<String, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

// 2. 分組 + 統計
Map<String, Long> countByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.counting()
    ));

// 3. 分組 + 求和
Map<String, Integer> salaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.summingInt(Employee::getSalary)
    ));

// 4. 分割（二分）
Map<Boolean, List<Employee>> partitioned = employees.stream()
    .collect(Collectors.partitioningBy(
        e -> e.getSalary() > 50000
    ));

// 5. 字串連接
String names = employees.stream()
    .map(Employee::getName)
    .collect(Collectors.joining(", ", "[", "]"));

// 6. 統計摘要
IntSummaryStatistics stats = employees.stream()
    .collect(Collectors.summarizingInt(Employee::getSalary));
// stats.getCount(), getSum(), getMin(), getMax(), getAverage()

// 平行處理（適用於大量資料、CPU 密集型操作）
long count = employees.parallelStream()
    .filter(e -> e.getSalary() > 50000)
    .count();

// 或從 stream 轉換
long count = employees.stream()
    .parallel()
    .filter(e -> e.getSalary() > 50000)
    .count();

// 1. 建立空的 Optional
Optional<String> empty = Optional.empty();

// 2. 建立非空 Optional（值不可為 null）
Optional<String> hello = Optional.of("Hello");

// 3. 建立可能為空的 Optional
Optional<String> nullable = Optional.ofNullable(getValue());

// ✅ 正確：使用 ifPresent
optional.ifPresent(value -> System.out.println(value));

// ✅ 正確：使用 map 轉換
Optional<Integer> length = optional.map(String::length);

// ✅ 正確：使用 orElse 提供預設值
String result = optional.orElse("預設值");

// ✅ 正確：使用 orElseGet 延遲計算預設值
String result = optional.orElseGet(() -> computeDefault());

// ✅ 正確：使用 orElseThrow 拋出例外
String result = optional.orElseThrow(
    () -> new IllegalStateException("值不存在")
);

// ✅ Java 9+：ifPresentOrElse
optional.ifPresentOrElse(
    value -> System.out.println(value),
    () -> System.out.println("值不存在")
);

// ✅ Java 9+：or 提供替代 Optional
Optional<String> result = optional.or(() -> Optional.of("替代值"));

// ❌ 錯誤：使用 isPresent + get
if (optional.isPresent()) {
    String value = optional.get();  // 這與 null 檢查沒有差別
}

// ❌ 錯誤：將 Optional 用於欄位
public class User {
    private Optional<String> nickname;  // 不建議
}

// ❌ 錯誤：將 Optional 用於方法參數
public void process(Optional<String> input) {  // 不建議
}

// ❌ 錯誤：將 Optional 放入集合
List<Optional<String>> list;  // 不建議

// 查詢使用者的公司地址
public String getCompanyAddress(Long userId) {
    return Optional.ofNullable(userRepository.findById(userId))
        .map(User::getDepartment)
        .map(Department::getCompany)
        .map(Company::getAddress)
        .map(Address::getFullAddress)
        .orElse("地址未知");
}

// Java 7 等效寫法（大量 null 檢查）
public String getCompanyAddressOld(Long userId) {
    User user = userRepository.findById(userId);
    if (user != null) {
        Department dept = user.getDepartment();
        if (dept != null) {
            Company company = dept.getCompany();
            if (company != null) {
                Address address = company.getAddress();
                if (address != null) {
                    return address.getFullAddress();
                }
            }
        }
    }
    return "地址未知";
}

// Java 8：在介面中加入預設方法
public interface Collection<E> {
    // 既有方法...
    
    // 新增的預設方法，不會破壞既有實作
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    
    default void forEach(Consumer<? super E> action) {
        for (E e : this) {
            action.accept(e);
        }
    }
}

// 定義具有預設行為的介面
public interface Auditable {
    
    LocalDateTime getCreatedAt();
    LocalDateTime getUpdatedAt();
    
    // 預設方法
    default String getAuditInfo() {
        return String.format("建立時間: %s, 更新時間: %s",
            getCreatedAt(), getUpdatedAt());
    }
    
    default boolean isModified() {
        return !getCreatedAt().equals(getUpdatedAt());
    }
}

// 實作類別自動獲得預設方法
public class Order implements Auditable {
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    @Override
    public LocalDateTime getCreatedAt() { return createdAt; }
    
    @Override
    public LocalDateTime getUpdatedAt() { return updatedAt; }
    
    // getAuditInfo() 和 isModified() 自動可用
}

interface A {
    default void hello() {
        System.out.println("A");
    }
}

interface B {
    default void hello() {
        System.out.println("B");
    }
}

// 必須明確指定使用哪個實作
class C implements A, B {
    @Override
    public void hello() {
        A.super.hello();  // 呼叫 A 的預設方法
        // 或 B.super.hello();
        // 或完全自己實作
    }
}

// 需求：找出薪資超過 50000 的員工姓名，轉為大寫，按字母排序

// Java 7 寫法
List<String> result = new ArrayList<>();
for (Employee emp : employees) {
    if (emp.getSalary() > 50000) {
        result.add(emp.getName().toUpperCase());
    }
}
Collections.sort(result);

// Java 8 寫法
List<String> result = employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .map(e -> e.getName().toUpperCase())
    .sorted()
    .collect(Collectors.toList());

// 需求：按部門分組，統計每個部門的平均薪資

// Java 7 寫法
Map<String, List<Employee>> byDept = new HashMap<>();
for (Employee emp : employees) {
    String dept = emp.getDepartment();
    if (!byDept.containsKey(dept)) {
        byDept.put(dept, new ArrayList<>());
    }
    byDept.get(dept).add(emp);
}
Map<String, Double> avgSalaryByDept = new HashMap<>();
for (Map.Entry<String, List<Employee>> entry : byDept.entrySet()) {
    double sum = 0;
    for (Employee emp : entry.getValue()) {
        sum += emp.getSalary();
    }
    avgSalaryByDept.put(entry.getKey(), sum / entry.getValue().size());
}

// Java 8 寫法
Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingDouble(Employee::getSalary)
    ));

// 需求：取得使用者的暱稱，沒有則用使用者名稱，都沒有則用 "Anonymous"

// Java 7 寫法
String displayName;
if (user != null) {
    if (user.getNickname() != null) {
        displayName = user.getNickname();
    } else if (user.getUsername() != null) {
        displayName = user.getUsername();
    } else {
        displayName = "Anonymous";
    }
} else {
    displayName = "Anonymous";
}

// Java 8 寫法
String displayName = Optional.ofNullable(user)
    .map(User::getNickname)
    .or(() -> Optional.ofNullable(user).map(User::getUsername))
    .orElse("Anonymous");

// 更簡潔的寫法（Java 9+）
String displayName = Optional.ofNullable(user)
    .flatMap(u -> Optional.ofNullable(u.getNickname())
        .or(() -> Optional.ofNullable(u.getUsername())))
    .orElse("Anonymous");

// ❌ 誤用 1：在 Lambda 中修改外部變數
int count = 0;
list.forEach(item -> count++);  // 編譯錯誤！

// ✅ 正確做法
long count = list.stream().count();

// ❌ 誤用 2：對同一個 Stream 多次操作
Stream<String> stream = list.stream();
stream.forEach(System.out::println);
stream.count();  // 執行時期錯誤！Stream 已關閉

// ✅ 正確做法：每次建立新的 Stream
list.stream().forEach(System.out::println);
long count = list.stream().count();

// ❌ 誤用 3：在 Stream 中使用副作用
List<String> results = new ArrayList<>();
list.stream()
    .filter(s -> s.length() > 3)
    .forEach(s -> results.add(s));  // 不建議

// ✅ 正確做法
List<String> results = list.stream()
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

// ❌ 誤用 4：過度使用 Optional
public Optional<User> findUser(Optional<Long> id) {  // 參數不應是 Optional
    // ...
}

// ✅ 正確做法
public Optional<User> findUser(Long id) {
    if (id == null) {
        return Optional.empty();
    }
    return Optional.ofNullable(repository.findById(id));
}

List<String> list = Arrays.asList("a", "b", "c");
list.stream()
    .map(s -> {
        System.out.print(s);
        return s.toUpperCase();
    });
System.out.println("done");

// A
Comparator<String> c = (String s1, String s2) -> s1.compareTo(s2);

// B  
Comparator<String> c = (s1, s2) -> { return s1.compareTo(s2); };

// C
Comparator<String> c = (s1, s2) -> s1.compareTo(s2);

// D
以上皆是

// 檔案位置：src/main/java/module-info.java

module com.tutorial.myapp {
    
    // 1. requires - 宣告依賴的模組
    requires java.base;           // 預設自動包含
    requires java.sql;            // 需要 JDBC
    requires java.logging;        // 需要日誌
    requires transitive com.google.gson;  // 傳遞依賴
    
    // 2. exports - 公開套件給其他模組
    exports com.tutorial.myapp.api;
    exports com.tutorial.myapp.model;
    
    // 3. exports...to - 限定公開對象
    exports com.tutorial.myapp.internal to com.tutorial.test;
    
    // 4. opens - 開放套件供反射存取
    opens com.tutorial.myapp.entity to org.hibernate.orm.core;
    
    // 5. uses - 宣告使用的服務
    uses com.tutorial.myapp.spi.Plugin;
    
    // 6. provides - 提供服務實作
    provides com.tutorial.myapp.spi.Plugin 
        with com.tutorial.myapp.plugin.DefaultPlugin;
}

my-modular-app/
├── src/
│   └── main/
│       └── java/
│           ├── module-info.java
│           └── com/
│               └── tutorial/
│                   └── app/
│                       ├── Main.java
│                       └── service/
│                           └── UserService.java
└── pom.xml

// module-info.java
module com.tutorial.app {
    requires java.logging;
    requires com.google.gson;
    
    exports com.tutorial.app;
    exports com.tutorial.app.service;
}

// Main.java
package com.tutorial.app;

import java.util.logging.Logger;

public class Main {
    private static final Logger logger = Logger.getLogger(Main.class.getName());
    
    public static void main(String[] args) {
        logger.info("模組化應用程式啟動");
        System.out.println("Hello from modular Java!");
    }
}

# 分析 JAR 的依賴
jdeps --list-deps myapp.jar

# 分析使用了哪些 JDK 內部 API
jdeps --jdk-internals myapp.jar

# 產生模組依賴圖
jdeps --dot-output deps myapp.jar

# 建立只包含必要模組的 JRE
jlink \
  --module-path $JAVA_HOME/jmods:mods \
  --add-modules com.tutorial.app \
  --output custom-jre \
  --compress=2 \
  --strip-debug \
  --no-header-files \
  --no-man-pages

# 結果：從 ~300MB 的完整 JRE 縮減至 ~30MB

# 大小比較
完整 JRE (Java 17):    約 300 MB
自訂 JRE (基本模組):    約 30-50 MB
減少比例:              80-90%

# 多階段建置
FROM eclipse-temurin:21-jdk AS builder
WORKDIR /app
COPY . .
RUN mvn package -DskipTests

# 使用 jlink 建立自訂 JRE
RUN jlink \
    --add-modules java.base,java.logging,java.sql \
    --strip-debug \
    --compress=2 \
    --no-header-files \
    --no-man-pages \
    --output /custom-jre

# 最終映像
FROM debian:bookworm-slim
COPY --from=builder /custom-jre /opt/java
COPY --from=builder /app/target/*.jar /app/app.jar
CMD ["/opt/java/bin/java", "-jar", "/app/app.jar"]

# 結果：Docker 映像從 ~500MB 縮減至 ~100MB

<!-- pom.xml 新增依賴以取代被移除的模組 -->

<!-- JAXB (XML 處理) -->
<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>4.0.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>4.0.3</version>
</dependency>

<!-- JAX-WS (Web Services) -->
<dependency>
    <groupId>jakarta.xml.ws</groupId>
    <artifactId>jakarta.xml.ws-api</artifactId>
    <version>4.0.0</version>
</dependency>

<!-- 常用註解 (@PostConstruct, @PreDestroy 等) -->
<dependency>
    <groupId>jakarta.annotation</groupId>
    <artifactId>jakarta.annotation-api</artifactId>
    <version>2.1.1</version>
</dependency>

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;

public class HttpClientDemo {
    
    // 建立共用的 HttpClient（執行緒安全，建議重複使用）
    private static final HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .connectTimeout(Duration.ofSeconds(10))
        .followRedirects(HttpClient.Redirect.NORMAL)
        .build();
    
    // 同步 GET 請求
    public String getSync(String url) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Accept", "application/json")
            .GET()
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return response.body();
    }
    
    // 非同步 GET 請求
    public CompletableFuture<String> getAsync(String url) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body);
    }
    
    // POST 請求（JSON）
    public String postJson(String url, String jsonBody) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        
        return response.body();
    }
}

// 1. 儲存檔案
HttpResponse<Path> response = client.send(
    request,
    HttpResponse.BodyHandlers.ofFile(Path.of("downloaded.pdf"))
);

// 2. 串流處理
HttpResponse<Stream<String>> response = client.send(
    request,
    HttpResponse.BodyHandlers.ofLines()
);
response.body().forEach(System.out::println);

// 3. 自訂回應處理
HttpResponse<JsonObject> response = client.send(
    request,
    responseInfo -> HttpResponse.BodySubscribers.mapping(
        HttpResponse.BodySubscribers.ofString(StandardCharsets.UTF_8),
        body -> JsonParser.parseString(body).getAsJsonObject()
    )
);

// Java 10 之前
Map<String, List<Employee>> employeesByDept = new HashMap<String, List<Employee>>();

// Java 10+ 使用 var
var employeesByDept = new HashMap<String, List<Employee>>();

// ✅ 正確使用
var list = new ArrayList<String>();     // 推斷為 ArrayList<String>
var stream = list.stream();             // 推斷為 Stream<String>
var length = "Hello".length();          // 推斷為 int
var now = LocalDateTime.now();          // 推斷為 LocalDateTime

// ✅ for 迴圈中使用
for (var item : items) {
    System.out.println(item);
}

// ✅ try-with-resources
try (var reader = new BufferedReader(new FileReader("file.txt"))) {
    var line = reader.readLine();
}

// ❌ 不可使用的情況
var x;                          // 錯誤：無法推斷型別
var y = null;                   // 錯誤：無法從 null 推斷
var z = () -> "hello";          // 錯誤：Lambda 需要目標型別
var arr = {1, 2, 3};            // 錯誤：陣列初始化需要型別

// ❌ 不可用於
public var field;               // 錯誤：不能用於欄位
public void method(var param) {} // 錯誤：不能用於參數
public var getValue() {}        // 錯誤：不能用於回傳型別

// ✅ 好的使用：型別顯而易見
var users = new ArrayList<User>();
var response = httpClient.send(request, BodyHandlers.ofString());
var mapper = new ObjectMapper();

// ❌ 不建議：降低可讀性
var result = process(data);  // result 是什麼型別？
var x = getValue();          // x 是什麼型別？

// 💡 建議：當右側能清楚看出型別時使用 var
var config = loadConfig();           // 不清楚
Configuration config = loadConfig(); // 清楚

// 強制使用 TLS 1.2 以上
System.setProperty("https.protocols", "TLSv1.2,TLSv1.3");
System.setProperty("jdk.tls.client.protocols", "TLSv1.2,TLSv1.3");

// 停用弱加密套件
System.setProperty("jdk.tls.disabledAlgorithms", 
    "SSLv3, TLSv1, TLSv1.1, RC4, DES, MD5withRSA, DH keySize < 1024, " +
    "EC keySize < 224, 3DES_EDE_CBC, anon, NULL");

# 檢視 JDK cacerts 內容
keytool -list -cacerts

# 匯入自簽憑證（Java 11+）
keytool -importcert -cacerts -file mycert.pem -alias myca

# Java 17+ 預設使用系統憑證庫（Windows/macOS）
# 可透過參數切換
-Djavax.net.ssl.trustStoreType=Windows-ROOT

// 問題 1：InaccessibleObjectException
// 原因：反射存取私有成員被阻擋

// 解決方案 A：在 module-info.java 中開放
opens com.myapp.entity to org.hibernate.orm.core;

// 解決方案 B：啟動參數（不建議長期使用）
--add-opens java.base/java.lang=ALL-UNNAMED

// 問題 2：NoClassDefFoundError: javax/xml/bind/JAXBException
// 原因：JAXB 已從 JDK 移除

// 解決方案：加入依賴
<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>4.0.0</version>
</dependency>

// A
var list = new ArrayList<>();

// B
var x = null;

// C
for (var i = 0; i < 10; i++) {}

// D
var func = (String s) -> s.length();

// Java 11 之前：傳統 switch 語句
String dayType;
switch (day) {
    case MONDAY:
    case TUESDAY:
    case WEDNESDAY:
    case THURSDAY:
    case FRIDAY:
        dayType = "工作日";
        break;
    case SATURDAY:
    case SUNDAY:
        dayType = "週末";
        break;
    default:
        dayType = "未知";
}

// Java 14+：Switch Expression（箭頭語法）
String dayType = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "工作日";
    case SATURDAY, SUNDAY -> "週末";
};

// 需要多行時使用 yield
String dayType = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> {
        logger.info("這是工作日");
        yield "工作日";
    }
    case SATURDAY, SUNDAY -> {
        logger.info("這是週末");
        yield "週末";
    }
};

// enum 必須涵蓋所有值，或提供 default
enum Status { PENDING, APPROVED, REJECTED }

String message = switch (status) {
    case PENDING -> "待處理";
    case APPROVED -> "已核准";
    case REJECTED -> "已拒絕";
    // 不需要 default，因為已涵蓋所有 enum 值
};

// 若 enum 新增值，編譯器會警告未處理

// 範例：HTTP 狀態碼處理
public String getStatusMessage(int statusCode) {
    return switch (statusCode) {
        case 200 -> "成功";
        case 201 -> "已建立";
        case 400 -> "請求錯誤";
        case 401 -> "未授權";
        case 403 -> "禁止存取";
        case 404 -> "找不到資源";
        case 500 -> "伺服器錯誤";
        default -> "未知狀態：" + statusCode;
    };
}

// 範例：命令處理
public void executeCommand(String command) {
    switch (command.toLowerCase()) {
        case "start", "run", "execute" -> startProcess();
        case "stop", "halt", "terminate" -> stopProcess();
        case "pause", "suspend" -> pauseProcess();
        case "status", "info" -> showStatus();
        default -> throw new IllegalArgumentException("未知命令：" + command);
    }
}

// Java 14 之前：字串串接
String html = "<html>\n" +
              "    <body>\n" +
              "        <p>Hello, World!</p>\n" +
              "    </body>\n" +
              "</html>";

// Java 14 之前：單行（難以閱讀）
String json = "{\"name\":\"Alice\",\"age\":30,\"email\":\"alice@example.com\"}";

// Java 15+：Text Block
String html = """
    <html>
        <body>
            <p>Hello, World!</p>
        </body>
    </html>
    """;

String json = """
    {
        "name": "Alice",
        "age": 30,
        "email": "alice@example.com"
    }
    """;

String sql = """
    SELECT u.id, u.name, u.email
    FROM users u
    JOIN orders o ON u.id = o.user_id
    WHERE o.status = 'PENDING'
    ORDER BY o.created_at DESC
    """;

// 結尾 """ 的位置決定基準縮排

// 範例 1：結尾在新行，無額外縮排
String s1 = """
    line1
    line2
    """;
// 結果：每行前面沒有空格

// 範例 2：結尾有縮排
String s2 = """
    line1
    line2
""";
// 結果：每行前面有 4 個空格

// 範例 3：使用 stripIndent()（已自動套用）
String s3 = """
        line1
        line2
    """.stripIndent();

// 1. 保留行尾空格：使用 \s
String s = """
    line with trailing space\s
    another line
    """;

// 2. 不換行：使用 \
String singleLine = """
    This is a very long line that \
    we want to keep on one line \
    in the output.
    """;
// 結果：一行

// 3. 格式化：使用 formatted()
String template = """
    Hello, %s!
    Your balance is $%.2f.
    """;
String message = template.formatted("Alice", 1234.56);

// SQL 模板
private static final String FIND_USER_SQL = """
    SELECT 
        u.id,
        u.username,
        u.email,
        u.created_at
    FROM users u
    WHERE u.status = ?
      AND u.department_id = ?
    ORDER BY u.created_at DESC
    LIMIT ?
    """;

// HTML 模板
public String generateEmailBody(String name, String content) {
    return """
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>通知郵件</title>
        </head>
        <body>
            <h1>親愛的 %s，您好！</h1>
            <p>%s</p>
            <p>祝您順心！</p>
        </body>
        </html>
        """.formatted(name, content);
}

// JSON 模板
public String toJson(User user) {
    return """
        {
            "id": %d,
            "name": "%s",
            "email": "%s",
            "active": %b
        }
        """.formatted(
            user.getId(),
            user.getName(),
            user.getEmail(),
            user.isActive()
        );
}

// Java 15 之前：典型的資料類別
public final class Point {
    private final int x;
    private final int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int x() { return x; }
    public int y() { return y; }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point)) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
    
    @Override
    public String toString() {
        return "Point[x=" + x + ", y=" + y + "]";
    }
}

// Java 16+：Record
public record Point(int x, int y) {}

// 自動生成：
// - 私有 final 欄位
// - 公開建構子
// - 存取方法 x() 和 y()
// - equals()、hashCode()、toString()

// 自訂建構子（驗證）
public record User(String username, String email, int age) {
    
    // 緊湊建構子（Compact Constructor）
    public User {
        // 驗證邏輯
        if (username == null || username.isBlank()) {
            throw new IllegalArgumentException("使用者名稱不可為空");
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年齡必須在 0-150 之間");
        }
        // 正規化
        username = username.trim().toLowerCase();
        email = email.trim().toLowerCase();
    }
    
    // 額外的建構子
    public User(String username, String email) {
        this(username, email, 0);
    }
    
    // 額外的方法
    public String displayName() {
        return username + " <" + email + ">";
    }
    
    // 靜態工廠方法
    public static User of(String username, String email) {
        return new User(username, email);
    }
}

// ✅ 可以
public record Point(int x, int y) implements Serializable {}
public record Point(int x, int y) {
    public static Point ORIGIN = new Point(0, 0);
}

// ❌ 不可以
public record Point(int x, int y) extends SomeClass {}  // 不能繼承類別
public record Point(int x, int y) {
    private int z;  // 不能額外宣告實例欄位
}

// DTO 定義
public record UserDTO(
    Long id,
    String username,
    String email,
    LocalDateTime createdAt
) {
    public static UserDTO from(User entity) {
        return new UserDTO(
            entity.getId(),
            entity.getUsername(),
            entity.getEmail(),
            entity.getCreatedAt()
        );
    }
}

// API 回應
public record ApiResponse<T>(
    int code,
    String message,
    T data,
    LocalDateTime timestamp
) {
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "success", data, LocalDateTime.now());
    }
    
    public static <T> ApiResponse<T> error(int code, String message) {
        return new ApiResponse<>(code, message, null, LocalDateTime.now());
    }
}

// 組合鍵
public record CacheKey(String prefix, String id, String version) {
    @Override
    public String toString() {
        return prefix + ":" + id + ":" + version;
    }
}

// Java 15 之前
if (obj instanceof String) {
    String s = (String) obj;  // 冗餘的轉型
    System.out.println(s.length());
}

// Java 16+：Pattern Matching
if (obj instanceof String s) {
    System.out.println(s.length());  // 直接使用
}

// 變數在條件為真時可用
if (obj instanceof String s) {
    // s 可用
    System.out.println(s.toUpperCase());
}
// s 不可用

// 配合 && 使用
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s);
}

// 配合 || 使用（注意：此時 s 不可用）
if (!(obj instanceof String s) || s.isEmpty()) {
    // 當 obj 不是 String 時，s 不可用
    // 當 obj 是 String 且為空時，s 可用但已經是空的
}

// 在 else 分支中使用
if (!(obj instanceof String s)) {
    System.out.println("不是字串");
} else {
    System.out.println(s.toUpperCase());  // s 可用
}

// 範例 1：簡化類型檢查
public String format(Object value) {
    if (value instanceof String s) {
        return "字串：" + s;
    } else if (value instanceof Integer i) {
        return "整數：" + i;
    } else if (value instanceof Double d) {
        return "浮點數：" + String.format("%.2f", d);
    } else if (value instanceof List<?> list) {
        return "列表，大小：" + list.size();
    } else if (value instanceof Map<?, ?> map) {
        return "映射，大小：" + map.size();
    }
    return "未知類型：" + value.getClass().getName();
}

// 範例 2：equals 方法
public record Point(int x, int y) {
    @Override
    public boolean equals(Object obj) {
        return obj instanceof Point p 
            && this.x == p.x 
            && this.y == p.y;
    }
}

// 範例 3：配合 Optional
public void process(Optional<Object> opt) {
    opt.filter(o -> o instanceof String s && s.length() > 0)
       .ifPresent(System.out::println);
}

# 啟用 ZGC
java -XX:+UseZGC -Xmx16g -jar myapp.jar

# ZGC 主要特點：
# - 暫停時間 < 10ms（與堆大小無關）
# - 支援 TB 級堆記憶體
# - 並行執行，不影響應用執行緒
# - Java 21 引入 Generational ZGC（分代 ZGC）

# 啟用 Generational ZGC（Java 21+）
java -XX:+UseZGC -XX:+ZGenerational -jar myapp.jar

# 編譯時啟用
javac --enable-preview --release 21 MyClass.java

# 執行時啟用
java --enable-preview MyClass

# Maven 設定
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <release>21</release>
        <compilerArgs>
            <arg>--enable-preview</arg>
        </compilerArgs>
    </configuration>
</plugin>

// 定義密封類別，指定允許的子類別
public sealed class Shape 
    permits Circle, Rectangle, Triangle {
    
    // 共通屬性和方法
    public abstract double area();
}

// 子類別必須是 final、sealed 或 non-sealed

// final：不允許再被繼承
public final class Circle extends Shape {
    private final double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// sealed：繼續限制繼承
public sealed class Rectangle extends Shape 
    permits Square {
    
    protected final double width;
    protected final double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
}

// non-sealed：開放繼承
public non-sealed class Triangle extends Shape {
    private final double base;
    private final double height;
    
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

// Square 繼承自 sealed 的 Rectangle
public final class Square extends Rectangle {
    public Square(double side) {
        super(side, side);
    }
}

// Java 21+：Switch 的完整模式匹配
public String describe(Shape shape) {
    return switch (shape) {
        case Circle c -> "圓形，半徑 " + c.getRadius();
        case Square s -> "正方形，邊長 " + s.getSide();
        case Rectangle r -> "長方形，" + r.getWidth() + " x " + r.getHeight();
        case Triangle t -> "三角形，面積 " + t.area();
        // 由於是 sealed class，編譯器知道所有可能的子類別
        // 不需要 default 分支（如果 Triangle 是 non-sealed 則需要）
    };
}

// 範例：訂單狀態機
public sealed interface OrderState 
    permits PendingState, ConfirmedState, ShippedState, 
            DeliveredState, CancelledState {
    
    OrderState next();
    boolean canCancel();
}

public final class PendingState implements OrderState {
    @Override
    public OrderState next() {
        return new ConfirmedState();
    }
    
    @Override
    public boolean canCancel() {
        return true;
    }
}

public final class ConfirmedState implements OrderState {
    @Override
    public OrderState next() {
        return new ShippedState();
    }
    
    @Override
    public boolean canCancel() {
        return true;
    }
}

// ... 其他狀態

// 範例：表達式計算
public sealed interface Expr 
    permits Const, Add, Multiply, Negate {
}

public record Const(int value) implements Expr {}
public record Add(Expr left, Expr right) implements Expr {}
public record Multiply(Expr left, Expr right) implements Expr {}
public record Negate(Expr expr) implements Expr {}

// 計算表達式
public int evaluate(Expr expr) {
    return switch (expr) {
        case Const(int v) -> v;
        case Add(var l, var r) -> evaluate(l) + evaluate(r);
        case Multiply(var l, var r) -> evaluate(l) * evaluate(r);
        case Negate(var e) -> -evaluate(e);
    };
}

# Java 16 及之前：警告但允許
WARNING: An illegal reflective access operation has occurred

# Java 17+：預設拒絕，拋出異常
java.lang.reflect.InaccessibleObjectException: 
    Unable to make field private final byte[] java.lang.String.value accessible

# 方法 1：使用 --add-opens（暫時方案）
java --add-opens java.base/java.lang=ALL-UNNAMED -jar myapp.jar

# 方法 2：在 MANIFEST.MF 中宣告（不建議）
Add-Opens: java.base/java.lang=ALL-UNNAMED

# 方法 3：正確方式 - 修改程式碼，不使用內部 API

// 範例：使用 VarHandle 替代 Unsafe
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class VarHandleDemo {
    private int value;
    
    private static final VarHandle VALUE_HANDLE;
    
    static {
        try {
            VALUE_HANDLE = MethodHandles.lookup()
                .findVarHandle(VarHandleDemo.class, "value", int.class);
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    public void incrementAtomic() {
        VALUE_HANDLE.getAndAdd(this, 1);
    }
    
    public boolean compareAndSet(int expected, int newValue) {
        return VALUE_HANDLE.compareAndSet(this, expected, newValue);
    }
}

// 已淘汰，避免使用
@Deprecated(since = "9", forRemoval = true)
public final class Finalization {
    // 使用 Cleaner 替代 finalize()
}

// 替代方案：使用 Cleaner
import java.lang.ref.Cleaner;

public class Resource implements AutoCloseable {
    private static final Cleaner cleaner = Cleaner.create();
    private final Cleaner.Cleanable cleanable;
    private final State state;
    
    private static class State implements Runnable {
        // 清理所需的資源
        @Override
        public void run() {
            // 清理邏輯
            System.out.println("資源已清理");
        }
    }
    
    public Resource() {
        this.state = new State();
        this.cleanable = cleaner.register(this, state);
    }
    
    @Override
    public void close() {
        cleanable.clean();
    }
}

// Spring Boot 2.x (Java 8-17)
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.validation.constraints.NotNull;
import javax.servlet.http.HttpServletRequest;

// Spring Boot 3.x (Java 17+)
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.validation.constraints.NotNull;
import jakarta.servlet.http.HttpServletRequest;

# 1. 使用 OpenRewrite 自動遷移
mvn org.openrewrite.maven:rewrite-maven-plugin:run \
    -Drewrite.recipeArtifactCoordinates=\
        org.openrewrite.recipe:rewrite-spring:LATEST \
    -Drewrite.activeRecipes=\
        org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0

<!-- 2. 手動遷移：更新 pom.xml -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<properties>
    <java.version>17</java.version>
</properties>

// Java 22+ (正式版)
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

public class FFMDemo {
    
    public static void main(String[] args) throws Throwable {
        // 1. 配置記憶體區段（Memory Segment）
        try (Arena arena = Arena.ofConfined()) {
            // 配置 100 個整數的記憶體
            MemorySegment segment = arena.allocate(
                ValueLayout.JAVA_INT, 100
            );
            
            // 寫入資料
            for (int i = 0; i < 100; i++) {
                segment.setAtIndex(ValueLayout.JAVA_INT, i, i * 2);
            }
            
            // 讀取資料
            int value = segment.getAtIndex(ValueLayout.JAVA_INT, 50);
            System.out.println("Index 50: " + value);  // 100
        }
        // 離開 try 區塊時，記憶體自動釋放
    }
}

// 呼叫 C 標準函式庫的 strlen 函數
public class NativeFunctionDemo {
    
    public static void main(String[] args) throws Throwable {
        // 載入 C 標準函式庫
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();
        
        // 查找 strlen 函數
        MemorySegment strlenAddr = stdlib.find("strlen").orElseThrow();
        
        // 建立函數描述
        FunctionDescriptor strlenDesc = FunctionDescriptor.of(
            ValueLayout.JAVA_LONG,      // 回傳類型
            ValueLayout.ADDRESS         // 參數類型
        );
        
        // 建立方法控制代碼
        MethodHandle strlen = linker.downcallHandle(strlenAddr, strlenDesc);
        
        // 呼叫原生函數
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateFrom("Hello, World!");
            long length = (long) strlen.invokeExact(cString);
            System.out.println("字串長度: " + length);  // 13
        }
    }
}

// Java 22+ (孵化中)
import jdk.incubator.vector.*;

public class VectorDemo {
    
    // 選擇適合 CPU 的 Vector 種類
    static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
    
    // 向量化的陣列相加
    public static float[] vectorAdd(float[] a, float[] b) {
        float[] result = new float[a.length];
        int i = 0;
        
        // 向量化處理
        int upperBound = SPECIES.loopBound(a.length);
        for (; i < upperBound; i += SPECIES.length()) {
            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
            FloatVector vr = va.add(vb);
            vr.intoArray(result, i);
        }
        
        // 處理剩餘元素
        for (; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
        
        return result;
    }
    
    // 向量化的點積運算
    public static float dotProduct(float[] a, float[] b) {
        float sum = 0;
        int i = 0;
        
        int upperBound = SPECIES.loopBound(a.length);
        FloatVector vsum = FloatVector.zero(SPECIES);
        
        for (; i < upperBound; i += SPECIES.length()) {
            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
            vsum = va.fma(vb, vsum);  // fused multiply-add
        }
        
        sum = vsum.reduceLanes(VectorOperators.ADD);
        
        for (; i < a.length; i++) {
            sum += a[i] * b[i];
        }
        
        return sum;
    }
}

// 基準測試結果（示意）

// 傳統迴圈
public static float[] normalAdd(float[] a, float[] b) {
    float[] result = new float[a.length];
    for (int i = 0; i < a.length; i++) {
        result[i] = a[i] + b[i];
    }
    return result;
}

// 效能比較（1000 萬元素陣列）
// 傳統迴圈：~15ms
// Vector API：~3ms
// 加速比：約 5x

# 檢視 JIT 編譯日誌
java -XX:+PrintCompilation -jar myapp.jar

# 輸出範例
#     1    java.lang.Object::<init> (1 bytes)
#     2    java.lang.String::hashCode (55 bytes)
# 編號  類別名稱::方法名稱 (位元組碼大小)

# 分層編譯（Java 8+ 預設開啟）
java -XX:+TieredCompilation -jar myapp.jar

# 查看內聯決策
java -XX:+PrintInlining -jar myapp.jar

# 1. Class Data Sharing (CDS) - 共享類別資料
# 建立共享存檔
java -Xshare:dump

# 使用共享存檔
java -Xshare:on -jar myapp.jar

# 2. Application CDS (AppCDS) - 應用程式類別共享
# 建立類別列表
java -XX:DumpLoadedClassList=classes.lst -jar myapp.jar

# 建立 AppCDS 存檔
java -Xshare:dump -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app-cds.jsa -jar myapp.jar

# 使用 AppCDS 存檔
java -Xshare:on -XX:SharedArchiveFile=app-cds.jsa -jar myapp.jar

# 效果：啟動時間可減少 20-30%

# G1 GC 調優（Java 9+ 預設）
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:G1HeapRegionSize=16m \
     -jar myapp.jar

# 大型堆記憶體建議
java -XX:+UseG1GC \
     -Xms16g -Xmx16g \
     -XX:+AlwaysPreTouch \
     -jar myapp.jar

# 低延遲場景（Java 15+）
java -XX:+UseZGC \
     -Xms8g -Xmx8g \
     -jar myapp.jar

# Java 15：ZGC 正式支援
java -XX:+UseZGC -jar myapp.jar

# Java 18-20：持續改進
# - 支援 String Deduplication
# - 改進 NUMA 支援
# - 提升吞吐量

# Java 21：Generational ZGC
java -XX:+UseZGC -XX:+ZGenerational -jar myapp.jar

// 使用 JMX 監控 GC
import java.lang.management.*;

public class GCMonitor {
    
    public static void printGCStats() {
        for (GarbageCollectorMXBean gc : 
                ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.printf("GC: %s%n", gc.getName());
            System.out.printf("  次數: %d%n", gc.getCollectionCount());
            System.out.printf("  總時間: %d ms%n", gc.getCollectionTime());
        }
    }
    
    public static void printMemoryUsage() {
        MemoryMXBean memory = ManagementFactory.getMemoryMXBean();
        
        MemoryUsage heap = memory.getHeapMemoryUsage();
        System.out.printf("Heap: used=%d MB, max=%d MB%n",
            heap.getUsed() / 1024 / 1024,
            heap.getMax() / 1024 / 1024);
        
        MemoryUsage nonHeap = memory.getNonHeapMemoryUsage();
        System.out.printf("Non-Heap: used=%d MB%n",
            nonHeap.getUsed() / 1024 / 1024);
    }
}

// 方法 1：Thread.startVirtualThread()
Thread.startVirtualThread(() -> {
    System.out.println("Hello from virtual thread!");
});

// 方法 2：Thread.ofVirtual()
Thread vThread = Thread.ofVirtual()
    .name("my-virtual-thread")
    .start(() -> {
        System.out.println("Hello!");
    });
vThread.join();

// 方法 3：使用 ExecutorService
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        final int taskId = i;
        executor.submit(() -> {
            // 每個任務一個虛擬執行緒
            Thread.sleep(Duration.ofSeconds(1));
            return "Task " + taskId + " completed";
        });
    }
}
// 離開 try 區塊時，會等待所有任務完成

// 傳統方式：Thread Pool
ExecutorService executor = Executors.newFixedThreadPool(200);
// 限制同時處理 200 個請求

// Virtual Thread 方式
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 可同時處理數萬個請求

// 完整範例：簡單 HTTP 伺服器
public class VirtualThreadHttpServer {
    
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            while (true) {
                Socket socket = serverSocket.accept();
                executor.submit(() -> handleRequest(socket));
            }
        }
    }
    
    private static void handleRequest(Socket socket) {
        try (socket;
             var reader = new BufferedReader(
                 new InputStreamReader(socket.getInputStream()));
             var writer = new PrintWriter(socket.getOutputStream(), true)) {
            
            // 讀取請求（阻塞操作，但不會佔用 OS 執行緒）
            String requestLine = reader.readLine();
            
            // 模擬資料庫查詢（阻塞操作）
            Thread.sleep(Duration.ofMillis(100));
            
            // 發送回應
            writer.println("HTTP/1.1 200 OK");
            writer.println("Content-Type: text/plain");
            writer.println();
            writer.println("Hello, World!");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 模擬 10,000 個並發請求，每個請求耗時 1 秒

// 方案 1：Fixed Thread Pool（傳統）
var start = System.currentTimeMillis();
try (var executor = Executors.newFixedThreadPool(200)) {
    var futures = new ArrayList<Future<String>>();
    for (int i = 0; i < 10000; i++) {
        futures.add(executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "done";
        }));
    }
    futures.forEach(f -> {
        try { f.get(); } catch (Exception e) {}
    });
}
var elapsed = System.currentTimeMillis() - start;
System.out.println("Thread Pool: " + elapsed + " ms");
// 預期：約 50 秒（10000 / 200 * 1s）

// 方案 2：Virtual Thread
start = System.currentTimeMillis();
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    var futures = new ArrayList<Future<String>>();
    for (int i = 0; i < 10000; i++) {
        futures.add(executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "done";
        }));
    }
    futures.forEach(f -> {
        try { f.get(); } catch (Exception e) {}
    });
}
elapsed = System.currentTimeMillis() - start;
System.out.println("Virtual Thread: " + elapsed + " ms");
// 預期：約 1-2 秒

// Java 21 (Preview) / Java 22+ (Second Preview)
import java.util.concurrent.StructuredTaskScope;

public class StructuredConcurrencyDemo {
    
    record User(String name, String email) {}
    record Order(String id, double amount) {}
    record UserDetails(User user, List<Order> orders) {}
    
    // 並行獲取使用者資訊和訂單
    public UserDetails fetchUserDetails(String userId) throws Exception {
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 並行啟動兩個子任務
            Subtask<User> userTask = scope.fork(() -> fetchUser(userId));
            Subtask<List<Order>> ordersTask = scope.fork(() -> fetchOrders(userId));
            
            // 等待所有任務完成（或任一失敗）
            scope.join();
            
            // 如果有任務失敗，拋出異常
            scope.throwIfFailed();
            
            // 組合結果
            return new UserDetails(userTask.get(), ordersTask.get());
        }
    }
    
    // 取得最快回應（任一成功即可）
    public String fetchFromFastestServer() throws Exception {
        
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            
            scope.fork(() -> fetchFromServer("server1.example.com"));
            scope.fork(() -> fetchFromServer("server2.example.com"));
            scope.fork(() -> fetchFromServer("server3.example.com"));
            
            scope.join();
            
            // 返回最先成功的結果
            return scope.result();
        }
    }
    
    private User fetchUser(String userId) {
        // 模擬資料庫查詢
        return new User("Alice", "alice@example.com");
    }
    
    private List<Order> fetchOrders(String userId) {
        // 模擬資料庫查詢
        return List.of(new Order("ORD-001", 100.0));
    }
    
    private String fetchFromServer(String server) {
        // 模擬網路請求
        return "Response from " + server;
    }
}

// CompletableFuture 方式（傳統）
public UserDetails fetchUserDetailsAsync(String userId) {
    CompletableFuture<User> userFuture = CompletableFuture
        .supplyAsync(() -> fetchUser(userId));
    CompletableFuture<List<Order>> ordersFuture = CompletableFuture
        .supplyAsync(() -> fetchOrders(userId));
    
    return userFuture.thenCombine(ordersFuture, UserDetails::new).join();
    
    // 問題：
    // - 錯誤處理複雜
    // - 取消難以協調
    // - 異常可能被吞掉
}

// Structured Concurrency 方式
public UserDetails fetchUserDetailsStructured(String userId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        var userTask = scope.fork(() -> fetchUser(userId));
        var ordersTask = scope.fork(() -> fetchOrders(userId));
        
        scope.join();
        scope.throwIfFailed();
        
        return new UserDetails(userTask.get(), ordersTask.get());
    }
    // 優點：
    // - 任務生命週期清楚
    // - 錯誤自動傳播
    // - 取消自動處理
}

// Java 21 (Preview) / Java 22+ (Second Preview)
import java.lang.ScopedValue;

public class ScopedValueDemo {
    
    // 宣告 ScopedValue
    private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
    private static final ScopedValue<String> TRANSACTION_ID = ScopedValue.newInstance();
    
    public void handleRequest(User user, String transactionId) {
        // 設定 ScopedValue 並執行程式碼
        ScopedValue.where(CURRENT_USER, user)
            .where(TRANSACTION_ID, transactionId)
            .run(() -> {
                processRequest();
            });
    }
    
    private void processRequest() {
        // 在任何深度的呼叫鏈中都可以取得
        User user = CURRENT_USER.get();
        String txId = TRANSACTION_ID.get();
        
        System.out.println("Processing for user: " + user.name());
        System.out.println("Transaction ID: " + txId);
        
        // 呼叫其他方法，仍然可以存取
        doBusinessLogic();
    }
    
    private void doBusinessLogic() {
        // ScopedValue 在整個呼叫鏈中可用
        User user = CURRENT_USER.get();
        logAudit("Business logic executed for " + user.name());
    }
    
    private void logAudit(String message) {
        String txId = TRANSACTION_ID.get();
        System.out.println("[" + txId + "] " + message);
    }
}

// ThreadLocal 問題
ThreadLocal<User> currentUser = new ThreadLocal<>();

public void handleRequest(User user) {
    try {
        currentUser.set(user);
        processRequest();
    } finally {
        currentUser.remove();  // 必須手動清理！
    }
}

// ScopedValue 解決方案
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

public void handleRequest(User user) {
    ScopedValue.where(CURRENT_USER, user).run(() -> {
        processRequest();
    });
    // 離開 scope 自動清理，無需手動處理
}

// ❌ 不適合：CPU 密集型運算
// Virtual Thread 無法提升 CPU 運算效能
for (int i = 0; i < 1000; i++) {
    Thread.startVirtualThread(() -> {
        // CPU 密集運算
        double result = 0;
        for (int j = 0; j < 1000000; j++) {
            result += Math.sin(j) * Math.cos(j);
        }
    });
}

// ❌ 不適合：使用 synchronized 的大量程式碼
// synchronized 會導致 Virtual Thread pinning（釘住 OS 執行緒）
Thread.startVirtualThread(() -> {
    synchronized (lock) {
        // 長時間持有鎖
        Thread.sleep(Duration.ofSeconds(10));
    }
});

// ✅ 建議改用 ReentrantLock
private final ReentrantLock lock = new ReentrantLock();

Thread.startVirtualThread(() -> {
    lock.lock();
    try {
        Thread.sleep(Duration.ofSeconds(10));
    } finally {
        lock.unlock();
    }
});

// 監控 Virtual Thread 數量
public class VirtualThreadMonitor {
    
    public static void printThreadInfo() {
        // 取得所有執行緒
        Thread[] threads = new Thread[Thread.activeCount()];
        Thread.enumerate(threads);
        
        long virtualCount = Arrays.stream(threads)
            .filter(Objects::nonNull)
            .filter(Thread::isVirtual)
            .count();
        
        long platformCount = Arrays.stream(threads)
            .filter(Objects::nonNull)
            .filter(t -> !t.isVirtual())
            .count();
        
        System.out.println("Virtual Threads: " + virtualCount);
        System.out.println("Platform Threads: " + platformCount);
    }
}

// JFR 監控（推薦）
// java -XX:StartFlightRecording=filename=recording.jfr,duration=60s -jar myapp.jar

// Spring Boot 3.2+ 支援 Virtual Thread
// application.properties
spring.threads.virtual.enabled=true

// 或 Java 配置
@Configuration
public class VirtualThreadConfig {
    
    @Bean
    public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadCustomizer() {
        return protocolHandler -> {
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        };
    }
}

// 批次處理：大量並行任務
public class BatchProcessor {
    
    public void processRecords(List<Record> records) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<?>> futures = new ArrayList<>();
            
            for (Record record : records) {
                futures.add(executor.submit(() -> {
                    // 每筆記錄一個 Virtual Thread
                    processRecord(record);
                }));
            }
            
            // 等待所有任務完成
            for (Future<?> future : futures) {
                try {
                    future.get();
                } catch (Exception e) {
                    handleError(e);
                }
            }
        }
    }
    
    private void processRecord(Record record) {
        // I/O 操作（資料庫、API 呼叫等）
        // Virtual Thread 會自動讓出 OS 執行緒
    }
}

// Kafka 消費者使用 Virtual Thread
public class KafkaVirtualThreadConsumer {
    
    public void startConsumers(int count) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < count; i++) {
                executor.submit(this::consumeMessages);
            }
        }
    }
    
    private void consumeMessages() {
        // 每個消費者一個 Virtual Thread
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                processMessage(record);
            }
        }
    }
}

// 步驟 1：識別 I/O 密集型程式碼
// 找出使用 Thread Pool 處理 I/O 的地方

// 步驟 2：替換 ExecutorService
// Before
ExecutorService executor = Executors.newFixedThreadPool(100);

// After
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// 步驟 3：移除 synchronized（如果可能）
// Before
synchronized (lock) {
    // ...
}

// After
lock.lock();
try {
    // ...
} finally {
    lock.unlock();
}

// 步驟 4：替換 ThreadLocal（如果適用）
// Before
private static final ThreadLocal<Context> CONTEXT = new ThreadLocal<>();

// After
private static final ScopedValue<Context> CONTEXT = ScopedValue.newInstance();

# 調整 ForkJoinPool 的 Platform Thread 數量
# （Virtual Thread 底層使用 ForkJoinPool）
java -Djdk.virtualThreadScheduler.parallelism=16 -jar myapp.jar

# 調整最大 Pool 大小
java -Djdk.virtualThreadScheduler.maxPoolSize=256 -jar myapp.jar

# 監控 pinning 情況
java -Djdk.tracePinnedThreads=full -jar myapp.jar

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            synchronized (sharedResource) {
                Thread.sleep(Duration.ofSeconds(1));
                // 處理共享資源
            }
        });
    }
}

// Java 21+：完整的 Switch Pattern Matching

// 1. Type Pattern
public String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "整數：" + i;
        case Long l -> "長整數：" + l;
        case Double d -> "浮點數：" + d;
        case String s -> "字串：" + s;
        case int[] arr -> "整數陣列，長度：" + arr.length;
        case null -> "null 值";
        default -> "未知類型：" + obj.getClass().getName();
    };
}

// 2. Guarded Pattern（條件守衛）
public String categorize(Object obj) {
    return switch (obj) {
        case Integer i when i < 0 -> "負整數";
        case Integer i when i == 0 -> "零";
        case Integer i when i > 0 -> "正整數";
        case String s when s.isEmpty() -> "空字串";
        case String s when s.length() < 10 -> "短字串";
        case String s -> "長字串";
        case null -> "null";
        default -> "其他";
    };
}

// 3. Null 處理
public String handleNull(String s) {
    return switch (s) {
        case null -> "null 值";
        case String str when str.isEmpty() -> "空字串";
        case String str -> "字串：" + str;
    };
}

// Java 22+：Unnamed Pattern Variables（_）
public double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle(double radius) -> Math.PI * radius * radius;
        case Rectangle(double w, double h) -> w * h;
        case Square(double side, _) -> side * side;  // 忽略第二個元素
    };
}

// 巢狀模式匹配
sealed interface Expr permits Const, Add, Neg {}
record Const(int value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
record Neg(Expr expr) implements Expr {}

public int evaluate(Expr expr) {
    return switch (expr) {
        case Const(int v) -> v;
        case Add(Const(int a), Const(int b)) -> a + b;  // 特化處理
        case Add(var left, var right) -> evaluate(left) + evaluate(right);
        case Neg(Const(int v)) -> -v;  // 特化處理
        case Neg(var e) -> -evaluate(e);
    };
}

// Record 定義
record Point(int x, int y) {}
record Rectangle(Point topLeft, Point bottomRight) {}

// Record Pattern 解構
public void printPoint(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println("x = " + x + ", y = " + y);
    }
}

// 巢狀 Record Pattern
public int calculateWidth(Object obj) {
    if (obj instanceof Rectangle(Point(int x1, int _), Point(int x2, int _))) {
        return Math.abs(x2 - x1);
    }
    return 0;
}

// 在 Switch 中使用
public String describeShape(Object obj) {
    return switch (obj) {
        case Point(int x, int y) when x == 0 && y == 0 -> "原點";
        case Point(int x, int y) when x == y -> "在對角線上";
        case Point(int x, int y) -> "點 (" + x + ", " + y + ")";
        case Rectangle(Point(int x1, int y1), Point(int x2, int y2)) -> 
            "矩形從 (" + x1 + "," + y1 + ") 到 (" + x2 + "," + y2 + ")";
        default -> "未知形狀";
    };
}

// 定義 JSON 值的 Sealed 類型
sealed interface JsonValue permits JsonString, JsonNumber, JsonBool, 
                                   JsonNull, JsonArray, JsonObject {}
                                   
record JsonString(String value) implements JsonValue {}
record JsonNumber(double value) implements JsonValue {}
record JsonBool(boolean value) implements JsonValue {}
record JsonNull() implements JsonValue {}
record JsonArray(List<JsonValue> values) implements JsonValue {}
record JsonObject(Map<String, JsonValue> fields) implements JsonValue {}

// 使用 Pattern Matching 處理 JSON
public String formatJson(JsonValue json) {
    return switch (json) {
        case JsonString(String s) -> "\"" + s + "\"";
        case JsonNumber(double n) -> String.valueOf(n);
        case JsonBool(boolean b) -> String.valueOf(b);
        case JsonNull() -> "null";
        case JsonArray(List<JsonValue> values) -> 
            "[" + values.stream()
                .map(this::formatJson)
                .collect(Collectors.joining(", ")) + "]";
        case JsonObject(Map<String, JsonValue> fields) ->
            "{" + fields.entrySet().stream()
                .map(e -> "\"" + e.getKey() + "\": " + formatJson(e.getValue()))
                .collect(Collectors.joining(", ")) + "}";
    };
}

// Java 22+ (Preview)
import java.lang.classfile.*;
import java.lang.constant.*;

public class ClassFileDemo {
    
    // 讀取 class 檔案
    public void analyzeClass(Path classFile) throws IOException {
        ClassModel classModel = ClassFile.of().parse(classFile);
        
        System.out.println("類別名稱：" + classModel.thisClass().asInternalName());
        System.out.println("父類別：" + classModel.superclass()
            .map(ce -> ce.asInternalName()).orElse("java/lang/Object"));
        
        System.out.println("方法：");
        for (MethodModel method : classModel.methods()) {
            System.out.println("  " + method.methodName().stringValue() + 
                              method.methodType().stringValue());
        }
        
        System.out.println("欄位：");
        for (FieldModel field : classModel.fields()) {
            System.out.println("  " + field.fieldName().stringValue() + 
                              ": " + field.fieldType().stringValue());
        }
    }
    
    // 產生 class 檔案
    public byte[] generateHelloWorld() {
        return ClassFile.of().build(
            ClassDesc.of("com.example", "HelloWorld"),
            classBuilder -> classBuilder
                .withFlags(ClassFile.ACC_PUBLIC)
                .withMethod(
                    "main",
                    MethodTypeDesc.of(ConstantDescs.CD_void, 
                                     ConstantDescs.CD_String.arrayType()),
                    ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
                    methodBuilder -> methodBuilder
                        .withCode(codeBuilder -> codeBuilder
                            .getstatic(
                                ClassDesc.of("java.lang", "System"),
                                "out",
                                ClassDesc.of("java.io", "PrintStream"))
                            .ldc("Hello, World!")
                            .invokevirtual(
                                ClassDesc.of("java.io", "PrintStream"),
                                "println",
                                MethodTypeDesc.of(ConstantDescs.CD_void, 
                                                 ConstantDescs.CD_String))
                            .return_()
                        )
                )
        );
    }
}

# 啟用 Generational ZGC
java -XX:+UseZGC -XX:+ZGenerational -jar myapp.jar

# Generational ZGC 優勢：
# - 分代收集，更有效率
# - 年輕代頻繁收集，老年代較少收集
# - 進一步降低延遲

# Docker / Kubernetes 環境建議設定
java \
  -XX:+UseContainerSupport \
  -XX:MaxRAMPercentage=75.0 \
  -XX:InitialRAMPercentage=50.0 \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -jar myapp.jar

# 說明：
# -XX:+UseContainerSupport    自動偵測容器記憶體限制
# -XX:MaxRAMPercentage=75.0   使用容器記憶體的 75% 作為最大堆
# -XX:InitialRAMPercentage    初始堆大小

// 1. GraalVM Native Image 支援
// 編譯為原生執行檔
// native-image -jar myapp.jar

// Spring Boot 3.x 原生支援
@SpringBootApplication
public class CloudNativeApp {
    
    public static void main(String[] args) {
        SpringApplication.run(CloudNativeApp.class, args);
    }
    
    // Native Image 友好的設計
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .build();
    }
}

// 2. 健康檢查端點
@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        if (isDatabaseHealthy()) {
            return Health.up().withDetail("database", "connected").build();
        }
        return Health.down().withDetail("database", "unavailable").build();
    }
}

// 使用 Vector API 進行向量運算（AI 推論）
public class VectorOperations {
    
    static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
    
    // 餘弦相似度計算（用於向量搜尋）
    public static float cosineSimilarity(float[] a, float[] b) {
        float dotProduct = 0, normA = 0, normB = 0;
        int i = 0;
        
        int upperBound = SPECIES.loopBound(a.length);
        FloatVector sumDot = FloatVector.zero(SPECIES);
        FloatVector sumNormA = FloatVector.zero(SPECIES);
        FloatVector sumNormB = FloatVector.zero(SPECIES);
        
        for (; i < upperBound; i += SPECIES.length()) {
            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
            sumDot = va.fma(vb, sumDot);
            sumNormA = va.fma(va, sumNormA);
            sumNormB = vb.fma(vb, sumNormB);
        }
        
        dotProduct = sumDot.reduceLanes(VectorOperators.ADD);
        normA = sumNormA.reduceLanes(VectorOperators.ADD);
        normB = sumNormB.reduceLanes(VectorOperators.ADD);
        
        // 處理剩餘元素
        for (; i < a.length; i++) {
            dotProduct += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        
        return (float) (dotProduct / (Math.sqrt(normA) * Math.sqrt(normB)));
    }
}

// 使用 FFM API 呼叫原生 AI 函式庫
public class NativeAILibrary {
    
    // 呼叫 ONNX Runtime 等原生推論引擎
    public float[] runInference(float[] input) {
        // 使用 FFM API 呼叫原生函數
        // ...
        return null;
    }
}

// Virtual Thread + Structured Concurrency 實現高並發
public class HighConcurrencyService {
    
    // 處理百萬級並發連接
    public void startServer() throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            while (true) {
                Socket socket = serverSocket.accept();
                executor.submit(() -> handleConnection(socket));
            }
        }
    }
    
    private void handleConnection(Socket socket) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 並行處理多個 I/O 操作
            var authTask = scope.fork(() -> authenticate(socket));
            var dataTask = scope.fork(() -> fetchData(socket));
            
            scope.join();
            scope.throwIfFailed();
            
            processRequest(authTask.get(), dataTask.get());
            
        } catch (Exception e) {
            handleError(e);
        }
    }
}

record Point(int x, int y) {}
record Line(Point start, Point end) {}

Object obj = new Line(new Point(0, 0), new Point(10, 10));

if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
    System.out.println("Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")");
}

// ❌ 問題：使用 sun.misc.Unsafe
import sun.misc.Unsafe;

public class UnsafeExample {
    private static final Unsafe unsafe = getUnsafe();
    
    private static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            return (Unsafe) f.get(null);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // 直接記憶體操作
    public long allocateMemory(long size) {
        return unsafe.allocateMemory(size);
    }
}

// ✅ 解決方案 1：使用 VarHandle（Java 9+）
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;

public class VarHandleExample {
    private volatile int counter;
    private static final VarHandle COUNTER;
    
    static {
        try {
            COUNTER = MethodHandles.lookup()
                .findVarHandle(VarHandleExample.class, "counter", int.class);
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    public int incrementAndGet() {
        return (int) COUNTER.getAndAdd(this, 1) + 1;
    }
}

// ✅ 解決方案 2：使用 Foreign Memory API（Java 22+）
import java.lang.foreign.*;

public class ForeignMemoryExample {
    public MemorySegment allocateMemory(long size) {
        return Arena.global().allocate(size);
    }
}

// ❌ 問題：反射存取私有成員
public class ReflectionProblem {
    public void accessPrivateField(Object obj) throws Exception {
        Field field = obj.getClass().getDeclaredField("privateField");
        field.setAccessible(true);  // Java 17+ 可能失敗
        Object value = field.get(obj);
    }
}

// Java 17+ 錯誤訊息：
// java.lang.reflect.InaccessibleObjectException: 
//   Unable to make field private ... accessible

// ✅ 解決方案 1：module-info.java 開放存取
// module com.myapp {
//     opens com.myapp.entity to org.hibernate.orm.core;
// }

// ✅ 解決方案 2：啟動參數（暫時方案）
// java --add-opens java.base/java.lang=ALL-UNNAMED -jar myapp.jar

// ✅ 解決方案 3：使用 MethodHandles（推薦）
public class MethodHandlesSolution {
    public Object accessField(Object obj, String fieldName) throws Exception {
        // 需要在同一模組內，或目標模組已開放
        MethodHandles.Lookup lookup = MethodHandles.privateLookupIn(
            obj.getClass(), MethodHandles.lookup());
        VarHandle handle = lookup.findVarHandle(
            obj.getClass(), fieldName, Object.class);
        return handle.get(obj);
    }
}

// ❌ 問題：自定義 ClassLoader 可能失敗
public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 存取 JDK 內部類別可能失敗
        byte[] bytes = loadClassData(name);
        return defineClass(name, bytes, 0, bytes.length);
    }
}

// ✅ 解決方案：使用 MethodHandles.Lookup.defineClass()（Java 9+）
public class ModernClassLoader {
    private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
    
    public Class<?> defineClass(byte[] bytes) throws IllegalAccessException {
        return LOOKUP.defineClass(bytes);
    }
}

// 問題 1：字元編碼
// Java 18+ 預設 UTF-8，舊系統可能依賴系統預設編碼

// ✅ 明確指定編碼
// 讀取檔案
Files.readString(path, StandardCharsets.UTF_8);
new InputStreamReader(is, StandardCharsets.UTF_8);

// 寫入檔案
Files.writeString(path, content, StandardCharsets.UTF_8);
new OutputStreamWriter(os, StandardCharsets.UTF_8);

// 問題 2：TLS 版本
// 舊系統可能使用 TLS 1.0/1.1，Java 17+ 預設停用

// ✅ 設定 TLS 版本
System.setProperty("https.protocols", "TLSv1.2,TLSv1.3");

// 或在 SSLContext 中設定
SSLContext ctx = SSLContext.getInstance("TLSv1.3");
ctx.init(null, null, null);

// 問題 3：加密演算法
// 某些弱加密演算法已被移除或停用

// ✅ 檢查 java.security 設定
// $JAVA_HOME/conf/security/java.security
// jdk.tls.disabledAlgorithms=...

# 1. 分析專案依賴
mvn dependency:tree > dependencies.txt

# 2. 檢查 JDK 內部 API 使用
jdeps --jdk-internals --multi-release 17 myapp.jar

# 3. 識別不相容的依賴
# 檢查各依賴的 Java 17/21 支援情況

<!-- 更新 Maven 版本（至少 3.6.3+） -->
<prerequisites>
    <maven>3.6.3</maven>
</prerequisites>

<!-- 更新編譯器插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <release>17</release>
    </configuration>
</plugin>

<!-- 需要升級的常見依賴 -->

<!-- Spring Boot 2.x → 3.x -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<!-- 資料庫驅動 -->
<dependency>
    <groupId>com.oracle.database.jdbc</groupId>
    <artifactId>ojdbc11</artifactId>  <!-- Java 17+ -->
    <version>23.3.0.23.09</version>
</dependency>

<!-- Hibernate -->
<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.4.0.Final</version>
</dependency>

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.16.0</version>
</dependency>

<!-- Log4j2（注意安全版本） -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.22.0</version>
</dependency>

// 1. javax → jakarta 命名空間變更
// 使用 IDE 或 OpenRewrite 自動修改

// Before
import javax.persistence.Entity;
import javax.servlet.http.HttpServletRequest;

// After
import jakarta.persistence.Entity;
import jakarta.servlet.http.HttpServletRequest;

// 2. 移除已淘汰 API
// Before
Date date = new Date();
int year = date.getYear();  // 已淘汰

// After
LocalDate date = LocalDate.now();
int year = date.getYear();

// 3. 替換不安全的反射
// Before
field.setAccessible(true);

// After（如果必須使用）
// 在 module-info.java 中開放，或使用啟動參數

// 建立升版測試清單
public class UpgradeTestSuite {
    
    @Test
    void testDatabaseConnection() {
        // 測試資料庫連接
    }
    
    @Test
    void testSerialization() {
        // 測試序列化/反序列化
    }
    
    @Test
    void testDateTimeHandling() {
        // 測試日期時間處理
    }
    
    @Test
    void testCharacterEncoding() {
        // 測試字元編碼
    }
    
    @Test
    void testHttpsConnection() {
        // 測試 HTTPS 連接（TLS 版本）
    }
    
    @Test
    void testReflection() {
        // 測試反射操作
    }
}

# 效能測試比較
# 記錄 Java 8 vs Java 17/21 的效能指標

# 1. 啟動時間
time java -jar myapp.jar

# 2. 記憶體使用
java -XX:+PrintFlagsFinal -jar myapp.jar | grep HeapSize

# 3. GC 暫停時間
java -Xlog:gc*:file=gc.log -jar myapp.jar

// 必考：Predicate、Function、Consumer、Supplier
Predicate<String> isEmpty = String::isEmpty;
Function<String, Integer> length = String::length;
Consumer<String> printer = System.out::println;
Supplier<LocalDate> today = LocalDate::now;

// 必考：方法參考四種類型
// 1. 靜態方法：ClassName::staticMethod
Function<String, Integer> parser = Integer::parseInt;

// 2. 實例方法（特定物件）：instance::method
String prefix = "Hello";
Function<String, String> concat = prefix::concat;

// 3. 實例方法（任意物件）：ClassName::instanceMethod
Function<String, String> upper = String::toUpperCase;

// 4. 建構子：ClassName::new
Supplier<ArrayList<String>> factory = ArrayList::new;

// 必考：中間操作 vs 終端操作
List<String> result = list.stream()
    .filter(s -> s.length() > 3)     // 中間：延遲執行
    .map(String::toUpperCase)         // 中間：延遲執行
    .sorted()                         // 中間：延遲執行
    .collect(Collectors.toList());    // 終端：觸發執行

// 必考：reduce 操作
int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);

// 必考：Collectors
Map<String, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

// 必考：Record 語法
public record Point(int x, int y) {
    // 緊湊建構子
    public Point {
        if (x < 0 || y < 0) throw new IllegalArgumentException();
    }
}

// 必考：Sealed Class
public sealed class Shape permits Circle, Rectangle {}
public final class Circle extends Shape {}
public non-sealed class Rectangle extends Shape {}

// 必考：instanceof Pattern Matching
if (obj instanceof String s) {
    System.out.println(s.length());
}

// 必考：Switch Pattern Matching（Java 21）
String result = switch (obj) {
    case Integer i -> "Integer: " + i;
    case String s -> "String: " + s;
    case null -> "null";
    default -> "Unknown";
};

// 問：以下程式碼輸出什麼？
Stream<String> stream = Stream.of("a", "b", "c")
    .filter(s -> {
        System.out.print(s);
        return true;
    });
System.out.println("done");

// 答：只輸出 "done"
// 原因：沒有終端操作，filter 不會執行

// 問：以下哪個會拋出異常？
Optional<String> opt = Optional.empty();

// A
opt.orElse("default");          // 正確：回傳 "default"

// B  
opt.orElseGet(() -> "default"); // 正確：回傳 "default"

// C
opt.orElseThrow();              // 拋出 NoSuchElementException

// D
opt.get();                       // 拋出 NoSuchElementException

// 問：以下哪些是合法的？

var list = new ArrayList<>();     // ✅ 合法（推斷為 ArrayList<Object>）
var x = null;                     // ❌ 無法推斷
var y = () -> "hello";            // ❌ Lambda 需要目標型別
var z = new int[]{1, 2, 3};       // ✅ 合法

// 問：以下程式碼是否正確？
public sealed class Animal permits Dog, Cat {}

// A - 在不同檔案
public class Dog extends Animal {}  // ❌ 必須是 final, sealed, 或 non-sealed

// B - 正確寫法
public final class Dog extends Animal {}  // ✅

// C - 未在 permits 列表
public final class Bird extends Animal {} // ❌ 編譯錯誤

# Java 升版檢查清單

## 1. 前置評估
- [ ] 確認目標 Java 版本
- [ ] 評估升版影響範圍
- [ ] 識別關鍵依賴
- [ ] 評估時程與資源需求
- [ ] 取得管理層支持

## 2. 環境準備
- [ ] 安裝目標版本 JDK
- [ ] 更新 IDE（IntelliJ / Eclipse / VS Code）
- [ ] 更新 Maven（3.6.3+）或 Gradle（7.0+）
- [ ] 建立測試環境
- [ ] 設定 CI/CD 環境

## 3. 依賴分析
- [ ] 執行 jdeps 分析內部 API 使用
- [ ] 列出所有第三方依賴
- [ ] 確認各依賴的相容版本
- [ ] 識別需要替換的依賴
- [ ] 確認授權相容性

## 4. 程式碼修改
- [ ] javax → jakarta 命名空間
- [ ] 移除 sun.* / com.sun.* 使用
- [ ] 更新已淘汰 API
- [ ] 修正反射存取問題
- [ ] 確認編碼設定
- [ ] 更新 TLS/加密設定

## 5. 建置設定
- [ ] 更新 pom.xml / build.gradle
- [ ] 設定編譯器版本
- [ ] 配置 module-info.java（如適用）
- [ ] 更新 JVM 啟動參數
- [ ] 調整 GC 設定

## 6. 測試驗證
- [ ] 單元測試 100% 通過
- [ ] 整合測試通過
- [ ] 效能測試（比較前後）
- [ ] 安全掃描通過
- [ ] 壓力測試
- [ ] 回歸測試

## 7. 部署準備
- [ ] 更新部署腳本
- [ ] 更新容器映像
- [ ] 更新伺服器 JDK
- [ ] 準備回滾計畫
- [ ] 準備監控告警

## 8. 上線執行
- [ ] 灰度發布
- [ ] 監控錯誤日誌
- [ ] 監控效能指標
- [ ] 監控 GC 行為
- [ ] 收集使用者回饋

## 9. 後續維護
- [ ] 更新技術文件
- [ ] 團隊知識分享
- [ ] 收集經驗教訓
- [ ] 規劃下次升版

# 記憶體設定
-Xms2g -Xmx2g          # 堆大小
-XX:MaxMetaspaceSize=256m  # Metaspace 大小

# GC 選擇
-XX:+UseG1GC           # G1 GC（預設）
-XX:+UseZGC            # ZGC（低延遲）
-XX:+UseParallelGC     # Parallel GC（吞吐量）

# 除錯
-XX:+HeapDumpOnOutOfMemoryError
-Xlog:gc*:file=gc.log

# 模組系統
--add-opens java.base/java.lang=ALL-UNNAMED
--add-modules java.se