Java 8新特性助你轻松编程：30个实用案例，一学就会，效率翻倍

在Java 8的版本中，Oracle公司为开发者带来了许多令人兴奋的新特性，这些特性使得Java编程变得更加简洁、高效。以下是Java 8中的一些关键新特性，以及如何通过30个实用案例来帮助你轻松掌握它们。

1. Lambda表达式

Lambda表达式是Java 8最引人注目的特性之一，它允许你以更简洁的方式编写函数式接口的实现。

案例：

// 使用Lambda表达式简化Comparator
Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
list.sort(comparator);
System.out.println(list);

2. Stream API

Stream API为集合操作提供了声明式编程风格，使数据处理更加直观。

案例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
int sum = numbers.stream().filter(n -> n % 2 == 0).mapToInt(n -> n * n).sum();
System.out.println(sum);

3. Optional类

Optional类旨在解决NullPointerException问题，使得代码更加健壮。

案例：

Optional<String> optional = Optional.ofNullable(getValue());
optional.ifPresent(System.out::println);

4. Date-Time API

Java 8引入了新的日期和时间API，简化了日期时间的操作。

案例：

LocalDate date = LocalDate.now();
System.out.println("Today's date: " + date);

5. 接口默认方法和静态方法

接口可以包含默认方法和静态方法，为接口提供更丰富的功能。

案例：

interface Animal {
    default void sound() {
        System.out.println("Animal makes a sound");
    }

    static void sleep() {
        System.out.println("Animal is sleeping");
    }
}

class Dog implements Animal {
    public void sound() {
        System.out.println("Woof!");
    }
}

Dog dog = new Dog();
dog.sound();
Animal.sleep();

6. 方法引用

方法引用提供了一种更简洁的方式来引用现有方法。

案例：

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
list.forEach(String::toUpperCase);

7. Completable Future

Completable Future提供了非阻塞的方式来进行异步编程。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Hello";
});
completableFuture.thenAccept(System.out::println);

8. 引入新功能：Map的forEach方法

Java 8在Map接口中引入了forEach方法，使得遍历Map更加方便。

案例：

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.forEach((key, value) -> System.out.println(key + ": " + value));

9. 新的集合类：List.of，Set.of，Map.of

Java 8提供了新的集合创建方法，使创建不可变集合更加简单。

案例：

List<String> list = List.of("Apple", "Banana", "Cherry");
Set<String> set = Set.of("Apple", "Banana", "Cherry");
Map<String, Integer> map = Map.of("Apple", 1, "Banana", 2);

10. 引入新功能：OptionalInt，OptionalDouble，OptionalLong

Java 8引入了Optional的变种，用于处理原始数据类型。

案例：

OptionalInt optionalInt = OptionalInt.of(10);
optionalInt.ifPresent(i -> System.out.println(i));

11. 新的数学功能：Math双精度函数

Java 8提供了新的双精度数学函数，用于更精确的计算。

案例：

double sqrt = Math.sqrt(16);
System.out.println(sqrt);

12. 新的文件I/O API

Java 8引入了新的文件I/O API，使得文件操作更加简单。

案例：

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

13. 新的并发API：CompletableFuture

CompletableFuture提供了更强大的异步编程功能。

案例：

CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    // 异步任务
});
completableFuture.join();

14. 新的并发API：CompletableFuture的thenApply，thenAccept，thenRun

这些方法允许你在异步任务完成后执行其他操作。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.thenApply(s -> "Welcome " + s).thenAccept(System.out::println);

15. 新的并发API：CompletableFuture的exceptionally，handle

这些方法允许你在异步任务出现异常时执行特定的操作。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    throw new RuntimeException("Something went wrong");
});
completableFuture.exceptionally(ex -> "Error: " + ex.getMessage()).thenAccept(System.out::println);

16. 新的并发API：CompletableFuture的allOf，anyOf

这些方法允许你处理多个异步任务。

案例：

CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(() -> {
    // 异步任务1
});
CompletableFuture<Void> completableFuture2 = CompletableFuture.runAsync(() -> {
    // 异步任务2
});
CompletableFuture<Void> allOf = CompletableFuture.allOf(completableFuture1, completableFuture2);
allOf.join();

17. 新的并发API：CompletableFuture的supplyAsync，runAsync

这些方法允许你以非阻塞的方式执行异步任务。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.thenAccept(System.out::println);

18. 新的并发API：CompletableFuture的thenCombine，thenAcceptBoth，thenRunAfterBoth

这些方法允许你在两个异步任务完成后执行特定的操作。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "World";
});
CompletableFuture<String> combined = completableFuture1.thenCombine(completableFuture2, (s1, s2) -> s1 + " " + s2);
combined.thenAccept(System.out::println);

19. 新的并发API：CompletableFuture的thenApplyAsync，thenAcceptAsync，thenRunAsync

这些方法允许你以异步的方式执行操作。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.thenApplyAsync(s -> "Welcome " + s).thenAccept(System.out::println);

20. 新的并发API：CompletableFuture的thenCompose

这个方法允许你将一个异步操作的结果传递给另一个异步操作。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = completableFuture1.thenCompose(s -> {
    return CompletableFuture.supplyAsync(() -> {
        // 异步任务2
        return "World";
    });
});
completableFuture2.thenAccept(System.out::println);

21. 新的并发API：CompletableFuture的whenComplete，handleAsync

这些方法允许你在异步任务完成后执行特定的操作，并且可以处理异常。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.whenComplete((result, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        System.out.println(result);
    }
});

22. 新的并发API：CompletableFuture的exceptionally

这个方法允许你在异步任务出现异常时执行特定的操作。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    throw new RuntimeException("Something went wrong");
});
completableFuture.exceptionally(ex -> "Error: " + ex.getMessage()).thenAccept(System.out::println);

23. 新的并发API：CompletableFuture的handle

这个方法允许你在异步任务完成后执行特定的操作，并且可以处理异常。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.handle((result, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        return result;
    }
});

24. 新的并发API：CompletableFuture的applyToEither

这个方法允许你在两个异步任务完成后选择其中一个的结果。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "World";
});
CompletableFuture<String> either = completableFuture1.applyToEither(completableFuture2, s -> s + " or " + s);
either.thenAccept(System.out::println);

25. 新的并发API：CompletableFuture的thenAcceptEither，thenRunAfterEither

这些方法允许你在两个异步任务完成后执行特定的操作。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "World";
});
CompletableFuture<Void> either = completableFuture1.thenAcceptEither(completableFuture2, System.out::println);
either.thenRun(() -> System.out.println("Completed either"));

26. 新的并发API：CompletableFuture的thenComposeAsync

这个方法允许你以异步的方式将一个异步操作的结果传递给另一个异步操作。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = completableFuture1.thenComposeAsync(s -> {
    return CompletableFuture.supplyAsync(() -> {
        // 异步任务2
        return "World";
    });
});
completableFuture2.thenAccept(System.out::println);

27. 新的并发API：CompletableFuture的thenAcceptBothAsync，thenRunAfterBothAsync

这些方法允许你在两个异步任务完成后执行特定的操作，并且可以以异步的方式执行。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "World";
});
CompletableFuture<Void> both = completableFuture1.thenAcceptBothAsync(completableFuture2, (s1, s2) -> {
    System.out.println(s1 + " " + s2);
});
both.thenRun(() -> System.out.println("Completed both"));

28. 新的并发API：CompletableFuture的thenCombineAsync，thenAcceptBothAsync，thenRunAfterBothAsync

这些方法允许你在两个异步任务完成后执行特定的操作，并且可以以异步的方式执行。

案例：

CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    // 异步任务1
    return "Hello";
});
CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "World";
});
CompletableFuture<Void> combined = completableFuture1.thenCombineAsync(completableFuture2, (s1, s2) -> s1 + " " + s2);
combined.thenAccept(System.out::println);

29. 新的并发API：CompletableFuture的whenCompleteAsync，handleAsync

这些方法允许你在异步任务完成后执行特定的操作，并且可以以异步的方式执行。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello";
});
completableFuture.whenCompleteAsync((result, ex) -> {
    if (ex != null) {
        ex.printStackTrace();
    } else {
        System.out.println(result);
    }
});

30. 新的并发API：CompletableFuture的exceptionallyAsync，handleAsync

这些方法允许你在异步任务出现异常时执行特定的操作，并且可以以异步的方式执行。

案例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    throw new RuntimeException("Something went wrong");
});
completableFuture.exceptionallyAsync(ex -> "Error: " + ex.getMessage()).thenAccept(System.out::println);

通过以上30个实用案例，你将能够轻松掌握Java 8的新特性，从而提高编程效率和代码质量。记住，实践是学习的关键，多尝试、多练习，你将很快成为Java 8编程的高手。