jdk1.8新特性 代码示例

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;

public class Java8Features {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. Lambda表达式示例
        System.out.println("=== Lambda表达式示例 ===");
        // 传统方式
        Comparator<String> comparator1 = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        };
        // Lambda方式
        Comparator<String> comparator2 = (s1, s2) -> s1.compareTo(s2);

        // 2. 函数式接口示例
        System.out.println("\n=== 函数式接口示例 ===");
        List<String> list = Arrays.asList("Java", "Python", "JavaScript");
        // 使用Lambda表达式实现自定义函数式接口
        StringProcessor processor = str -> str.toLowerCase();
        list.forEach(item -> System.out.println(processor.process(item)));

        // 3. Stream API示例
        System.out.println("\n=== Stream API示例 ===");
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 过滤偶数，映射平方值，并收集结果
        List<Integer> squaredEvens = numbers.stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .collect(Collectors.toList());
        System.out.println("偶数的平方：" + squaredEvens);

        // 4. Optional示例
        System.out.println("\n=== Optional示例 ===");
        String nullName = null;
        String name = "John";
        // 创建Optional实例
        Optional<String> optionalNull = Optional.ofNullable(nullName);
        Optional<String> optionalName = Optional.ofNullable(name);
        // 使用Optional
        System.out.println("空值的默认值：" + optionalNull.orElse("Unknown"));
        System.out.println("非空值：" + optionalName.orElse("Unknown"));

        // 5. 新的日期时间API示例
        System.out.println("\n=== 新的日期时间API示例 ===");
        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();
        
        System.out.println("当前日期：" + date);
        System.out.println("当前时间：" + time);
        System.out.println("当前日期时间：" + dateTime);
        
        // 日期时间格式化
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println("格式化后的日期时间：" + dateTime.format(formatter));

        // 6. 方法引用示例
        System.out.println("\n=== 方法引用示例 ===");
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        // 使用Lambda
        names.forEach(x -> System.out.println(x));
        // 使用方法引用
        names.forEach(System.out::println);

        // 7. 默认方法示例
        System.out.println("\n=== 默认方法示例 ===");
        Vehicle car = new Car();
        car.print();

        // 8. CompletableFuture异步编程示例
        System.out.println("\n=== CompletableFuture异步编程示例 ===");
        
        // supplyAsync: 创建一个异步任务，有返回值
        // 使用默认的ForkJoinPool.commonPool()作为线程池
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "World";
        });

        // thenCombine: 组合两个CompletableFuture的结果
        // 当两个任务都完成时，将结果传入BiFunction进行处理
        CompletableFuture<String> combinedFuture = future1
                .thenCombine(future2, (result1, result2) -> result1 + " " + result2);
        
        // get(): 阻塞等待获取异步任务的结果
        System.out.println("异步任务组合结果: " + combinedFuture.get());

        // 链式调用示例：
        // supplyAsync: 开始一个异步任务
        // thenApply: 对上一步的结果进行转换，返回新的CompletableFuture
        // String::toUpperCase: 方法引用，等同于 s -> s.toUpperCase()
        CompletableFuture<String> chainedFuture = CompletableFuture.supplyAsync(() -> "Hello")
                .thenApply(s -> s + " World")    // 转换结果
                .thenApply(String::toUpperCase); // 继续转换
        
        System.out.println("链式调用结果: " + chainedFuture.get());

        // exceptionally: 异常处理，当发生异常时，将异常传入函数进行处理
        // 类似于 try-catch，可以优雅地处理异步任务中的异常
        CompletableFuture<String> exceptionFuture = CompletableFuture.supplyAsync(() -> {
            if (true) throw new RuntimeException("发生异常");
            return "正常结果";
        }).exceptionally(throwable -> "Error: " + throwable.getMessage());
        
        System.out.println("异常处理结果: " + exceptionFuture.get());

        // allOf: 等待所有给定的CompletableFuture完成
        // 返回CompletableFuture<Void>
        // thenRun: 所有任务完成后执行一个Runnable，不使用前面的结果
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
        allOf.thenRun(() -> System.out.println("所有异步任务都已完成"));

        // thenAccept: 异步任务完成后，对结果进行消费，不返回新的值
        // 与thenApply的区别是：thenAccept返回CompletableFuture<Void>
        CompletableFuture.supplyAsync(() -> "异步操作")
                .thenAccept(result -> System.out.println("处理结果: " + result));

        // 等待一下确保异步操作完成
        Thread.sleep(2000);
    }
}

// 自定义函数式接口
@FunctionalInterface
interface StringProcessor {
    String process(String input);
}

// 默认方法示例
interface Vehicle {
    default void print() {
        System.out.println("我是一个交通工具");
    }
}

class Car implements Vehicle {
    // 可以选择重写默认方法
    @Override
    public void print() {
        System.out.println("我是一辆汽车");
    }
}