Java 9 主要引入了哪些新特性？

module-1
├─ src/main
│  └─ java
│     ├─ com.leileiluoluo.module1
│     │  ├─ model
│     │  │  └─ User.java
│     │  └─ util
│     │     └─ AgeUtil.java
│     └─ module-info.java
└─ pom.xml

module-2
├─ src/main
│  └─ java
│     ├─ com.leileiluoluo.module1
│     │  ├─ ModuleTest.java
│     └─ module-info.java
└─ pom.xml

// module-1: src/main/java/module-info.java
module leileiluoluo.module1 {
    exports com.leileiluoluo.module1.model;
}

// module-2: src/main/java/module-info.java
module leileiluoluo.module2 {
    requires leileiluoluo.module1;
}

// module-2: src/main/java/com/leileiluoluo/module2/ModuleTest.java
package com.leileiluoluo.module2;

import com.leileiluoluo.module1.model.User;

public class ModuleTest {

    public static void main(String[] args) {
        User user = new User("Larry", 28);

        System.out.println("name: " + user.getName());
        System.out.println("age: " + user.getAge());
        System.out.println("group: " + user.getAgeGroup());
    }
}

// src/main/java/TryWithResourcesTest.java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesTest {

    public static void testJava7ReadFileWithMultipleResources() throws IOException {
        String filePath = TryWithResourcesTest.class.getResource("test.txt").getPath();

        try (FileReader fr = new FileReader(filePath);
             BufferedReader br = new BufferedReader(fr)) {
            System.out.println(br.readLine());
        }
    }

    public static void testJava9ReadFileWithMultipleResources() throws IOException {
        String filePath = TryWithResourcesTest.class.getResource("test.txt").getPath();

        FileReader fr = new FileReader(filePath);
        BufferedReader br = new BufferedReader(fr);
        try (fr; br) {
            System.out.println(br.readLine());
        }
    }

    public static void main(String[] args) throws IOException {
        // java 7
        testJava7ReadFileWithMultipleResources();

        // java 9
        testJava9ReadFileWithMultipleResources();
    }
}

// src/main/java/PrivateInterfaceMethodsTest.java
public class PrivateInterfaceMethodsTest {

    public interface MyInterface {
        void abstractMethod();

        default void defaultMethod() {
            int result = privateMethod();
            System.out.println("Result: " + result);
        }

        static void staticMethod() {
            int result = privateStaticMethod();
            System.out.println("Result: " + result);
        }

        private int privateMethod() {
            return 28;
        }

        private static int privateStaticMethod() {
            return 39;
        }
    }

    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void abstractMethod() {
                System.out.println("Abstract Method Implemented!");
            }
        };

        myInterface.abstractMethod(); // Abstract Method Implemented!
        myInterface.defaultMethod(); // Result: 28
        MyInterface.staticMethod(); // Result: 39
    }
}

// src/main/java/CollectionFactoryMethodsTest.java
import java.util.*;

public class CollectionFactoryMethodsTest {

    public static void main(String[] args) {
        // Java 8: creating an unmodifiable list
        List<String> names = Arrays.asList("a", "b", "c");
        names = Collections.unmodifiableList(names);

        // Java 9: creating an unmodifiable list
        List<String> names2 = List.of("Larry", "Lucy", "Jacky");

        // Java 8: creating an unmodifiable set
        Set<Integer> numbers = new HashSet<>(Arrays.asList(1, 2, 3));
        numbers = Collections.unmodifiableSet(numbers);

        // Java 9: creating an unmodifiable set
        Set<Integer> numbers2 = Set.of(1, 2, 3);

        // Java 8: creating an unmodifiable map
        Map<String, Integer> nameAgeMap = new HashMap<>();
        nameAgeMap.put("Larry", 18);
        nameAgeMap.put("Lucy", 28);
        nameAgeMap.put("Jacky", 29);
        nameAgeMap = Collections.unmodifiableMap(nameAgeMap);

        // Java 9: creating an unmodifiable map
        Map<String, Integer> nameAgeMap2 = Map.of("Larry", 18, "Lucy", 28, "Jacky", 29);
    }
}

// src/main/java/StreamEnhancementsTest.java
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamEnhancementsTest {

    public static void main(String[] args) {
        // ofNullable() 使用样例
        String name = null;
        List<String> names = Stream.ofNullable(name)
                .collect(Collectors.toList());
        System.out.println(names); // []

        // takeWhile() 使用样例
        List<Integer> numbers = Stream.of(1, 2, 3, 4, 3, 2, 1)
                .takeWhile(num -> num < 4)
                .collect(Collectors.toList());
        System.out.println(numbers); // [1, 2, 3]

        // dropWhile() 使用样例
        List<Integer> numbers2 = Stream.of(1, 2, 3, 4, 3, 2, 1)
                .dropWhile(num -> num < 4)
                .collect(Collectors.toList());
        System.out.println(numbers2); // [4, 3, 2, 1]

        // iterate() 使用样例，Java 8 版本
        List<Integer> oddNumbers = Stream.iterate(1, v -> v + 2)
                .limit(5)
                .collect(Collectors.toList());
        System.out.println(oddNumbers); // [1, 3, 5, 7, 9]

        // iterate() 使用样例，Java 9 版本
        List<Integer> oddNumbers2 = Stream.iterate(1, v -> v < 10, v -> v + 2)
                .collect(Collectors.toList());
        System.out.println(oddNumbers2); // [1, 3, 5, 7, 9]
    }
}

// src/main/java/OptionalEnhancementsTest.java
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class OptionalEnhancementsTest {

    public static void main(String[] args) {
        // 使用 or() 方法设置备选值
        Optional<String> optional = Optional.empty();
        String result = optional.or(() -> Optional.of("Default value"))
                .orElse("Other value");
        System.out.println(result); // Default value

        // 使用 stream() 方法将 Optional 转换为 Stream
        List<String> names = Optional.of("Larry")
                .stream()
                .collect(Collectors.toList());
        System.out.println(names); // [Larry]

        // 使用 ifPresentOrElse() 方法执行操作
        Optional.empty()
                .ifPresentOrElse(
                        value -> System.out.println("Value: " + value),
                        () -> System.out.println("No value is present")
                ); // No value is present
    }
}

// src/main/java/ProcessAPITest.java
public class ProcessAPITest {

    public static void main(String[] args) {
        // 获取当前进程的信息
        ProcessHandle currentProcess = ProcessHandle.current();
        System.out.println("当前进程 PID: " + currentProcess.pid());
        System.out.println("当前进程是否存活: " + currentProcess.isAlive());
        System.out.println("当前进程信息: " + currentProcess.info());

        // 遍历所有进程并打印信息
        ProcessHandle.allProcesses().forEach(process -> {
            System.out.println("PID: " + process.pid());
            System.out.println("命令: " + process.info().command().orElse("未知"));
            System.out.println("启动时间: " + process.info().startInstant().orElse(null));
            System.out.println("------------------------");
        });

        // 异步处理进程退出事件
        ProcessHandle handle = ProcessHandle.of(currentProcess.pid()).orElseThrow(() -> new IllegalArgumentException("无效的进程 ID"));
        handle.onExit().thenAccept(process -> {
            System.out.println("进程 " + process.pid() + " 已退出");
        });

        // 销毁指定进程
        ProcessHandle processHandle = ProcessHandle.of(currentProcess.pid()).orElseThrow(() -> new IllegalArgumentException("无效的进程 ID"));
        boolean destroyed = processHandle.destroy(); // processHandle.destroyForcibly();
        if (destroyed) {
            System.out.println("进程 " + currentProcess.pid() + " 已被销毁");
        } else {
            System.out.println("无法销毁进程 " + currentProcess.pid());
        }
    }
}

// src/main/java/DiamondOperatorTest.java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DiamondOperatorTest {

    public static void main(String[] args) {
        // Java 8 以前，需要显式指定泛型参数
        List<String> list1 = new ArrayList<String>();

        // 在 Java 8 中，可以使用钻石操作符进行推断
        List<String> list2 = new ArrayList<>();

        // 在 Java 8 中，无法在匿名内部类中使用钻石操作符
        // 而在 Java 9 中则可以
        Runnable runnable = () -> {
            List<String> list = new ArrayList<>(); // 自动推断为 ArrayList<String>
            list.add("Java 9");
            System.out.println("Inside Runnable: " + list);
        };

        // 在 Java 9 中更复杂的嵌套泛型也能正确推断
        Map<String, List<Map<Integer, String>>> complexMap = new HashMap<>();
    }
}

// src/main/java/DeprecatedAnnotationTest.java
public class DeprecatedAnnotationTest {

    @Deprecated(since = "9", forRemoval = true)
    public static void method1() {
        // 即将废弃的方法实现
    }

    @Deprecated(since = "10") // forRemoval = false
    public static void method2() {
        // 过时的方法实现
    }

    public static void main(String[] args) {
        DeprecatedAnnotationTest.method1();
        DeprecatedAnnotationTest.method2();
    }
}