Java 8作为Java语言的一个重要版本，引入了许多新特性和改进，使得编程变得更加高效和简洁。本文将为你介绍Java 8的30个实用案例，帮助你快速上手这些新特性。
1. Lambda表达式
Lambda表达式是Java 8的一大亮点，它允许你以更简洁的方式编写代码。以下是一个使用Lambda表达式实现线程的例子：
Runnable r = () -> System.out.println("Hello, World!");
new Thread(r).start();
2. Stream API
Stream API提供了强大的数据处理能力，可以让你以声明式的方式处理集合。以下是一个使用Stream API计算集合中元素平方和的例子：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(i -> i * i).sum();
System.out.println(sum); // 输出：55
3. 方法引用
方法引用可以让你以更简洁的方式调用方法。以下是一个使用方法引用的例子：
List<String> strings = Arrays.asList("a", "b", "c");
strings.forEach(String::toUpperCase);
4. 默认方法
默认方法允许你为接口添加新的方法，而不需要修改实现这些接口的类。以下是一个使用默认方法的例子：
interface Animal {
default void makeSound() {
System.out.println("Some sound");
}
}
class Dog implements Animal {
// Dog类不需要实现makeSound方法，因为它已经继承了默认方法
}
Dog dog = new Dog();
dog.makeSound(); // 输出：Some sound
5. Date-Time API
Java 8引入了新的Date-Time API，提供了更易用的日期和时间处理方式。以下是一个使用Date-Time API获取当前日期的例子：
LocalDate date = LocalDate.now();
System.out.println(date); // 输出：当前日期
6. Optional类
Optional类可以避免空指针异常，提高代码的健壮性。以下是一个使用Optional类的例子：
Optional<String> optional = Optional.ofNullable(null);
optional.ifPresent(System.out::println); // 输出：无内容
7. 新的集合类
Java 8引入了新的集合类，如Map.Entry和Set，使得集合操作更加方便。以下是一个使用新集合类的例子：
Map<String, String> map = new HashMap<>();
map.put("key", "value");
String value = map.get("key");
System.out.println(value); // 输出：value
8. 新的并发API
Java 8提供了新的并发API，如CompletableFuture，使得并发编程更加简单。以下是一个使用新的并发API的例子：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, World!");
future.thenAccept(System.out::println); // 输出：Hello, World!
9. 新的数学函数
Java 8提供了新的数学函数，如Math.round()，使得数学运算更加方便。以下是一个使用新的数学函数的例子：
double value = 3.14159;
int roundedValue = Math.round(value);
System.out.println(roundedValue); // 输出：3
10. 新的文件API
Java 8提供了新的文件API，如Files和Paths，使得文件操作更加方便。以下是一个使用新的文件API的例子：
Path path = Paths.get("example.txt");
String content = new String(Files.readAllBytes(path));
System.out.println(content); // 输出：example.txt的内容
11. 新的日期时间格式化
Java 8提供了新的日期时间格式化方法，如DateTimeFormatter，使得日期时间格式化更加灵活。以下是一个使用新的日期时间格式化的例子：
LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);
System.out.println(formattedDateTime); // 输出：当前日期时间
12. 新的集合操作
Java 8提供了新的集合操作，如forEach和removeIf，使得集合操作更加方便。以下是一个使用新的集合操作的例子：
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println); // 输出：a, b, c
list.removeIf(s -> s.equals("b"));
System.out.println(list); // 输出：[a, c]
13. 新的字符串操作
Java 8提供了新的字符串操作，如repeat()和lines()，使得字符串操作更加方便。以下是一个使用新的字符串操作的例子：
String string = "Hello, World!";
String repeatedString = string.repeat(3);
System.out.println(repeatedString); // 输出：Hello, World!Hello, World!Hello, World!
String[] lines = string.lines().toArray(String[]::new);
System.out.println(Arrays.toString(lines)); // 输出：[Hello, World!]
14. 新的文件系统操作
Java 8提供了新的文件系统操作，如Files.copy()和Files.move()，使得文件操作更加方便。以下是一个使用新的文件系统操作的例子：
Path sourcePath = Paths.get("example.txt");
Path targetPath = Paths.get("example_copy.txt");
Files.copy(sourcePath, targetPath);
Files.move(sourcePath, targetPath);
15. 新的异常处理
Java 8提供了新的异常处理机制，如try-with-resources，使得异常处理更加方便。以下是一个使用新的异常处理的例子：
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();
}
16. 新的集合初始化器
Java 8提供了新的集合初始化器，如List.of()和Set.of()，使得集合初始化更加方便。以下是一个使用新的集合初始化器的例子：
List<String> list = List.of("a", "b", "c");
Set<String> set = Set.of("a", "b", "c");
17. 新的函数式接口
Java 8引入了许多新的函数式接口，如Function和Predicate，使得函数式编程更加方便。以下是一个使用新的函数式接口的例子：
Function<String, Integer> lengthFunction = String::length;
Predicate<String> evenLengthPredicate = s -> s.length() % 2 == 0;
18. 新的并发工具
Java 8提供了新的并发工具，如CompletableFuture和CompletableFuture.allOf()，使得并发编程更加方便。以下是一个使用新的并发工具的例子：
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
// 执行异步任务1
});
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
// 执行异步任务2
});
CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);
allFutures.join(); // 等待所有异步任务完成
19. 新的数学运算符
Java 8提供了新的数学运算符，如Math.pow()和Math.sqrt()，使得数学运算更加方便。以下是一个使用新的数学运算符的例子：
double value = Math.pow(2, 3);
double sqrtValue = Math.sqrt(16);
System.out.println(value); // 输出：8
System.out.println(sqrtValue); // 输出：4.0
20. 新的日期时间解析
Java 8提供了新的日期时间解析方法，如DateTimeFormatter.ofPattern()，使得日期时间解析更加灵活。以下是一个使用新的日期时间解析的例子：
String dateString = "2021-09-01 12:00:00";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.parse(dateString, formatter);
System.out.println(dateTime); // 输出：2021-09-01 12:00:00
21. 新的集合遍历
Java 8提供了新的集合遍历方法，如forEach()和forEachOrdered()，使得集合遍历更加方便。以下是一个使用新的集合遍历的例子：
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println); // 输出：a, b, c
list.forEachOrdered(System.out::println); // 输出：a, b, c
22. 新的集合排序
Java 8提供了新的集合排序方法，如List.sort()和Set.sort()，使得集合排序更加方便。以下是一个使用新的集合排序的例子：
List<String> list = Arrays.asList("c", "b", "a");
list.sort(String::compareTo);
System.out.println(list); // 输出：[a, b, c]
23. 新的集合转换
Java 8提供了新的集合转换方法，如List.stream()和Set.stream()，使得集合转换更加方便。以下是一个使用新的集合转换的例子：
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
24. 新的集合过滤
Java 8提供了新的集合过滤方法，如List.filter()和Set.filter()，使得集合过滤更加方便。以下是一个使用新的集合过滤的例子：
List<String> list = Arrays.asList("a", "b", "c");
List<String> filteredList = list.stream().filter(s -> s.equals("a")).collect(Collectors.toList());
System.out.println(filteredList); // 输出：[a]
25. 新的集合映射
Java 8提供了新的集合映射方法，如List.map()和Set.map()，使得集合映射更加方便。以下是一个使用新的集合映射的例子：
List<String> list = Arrays.asList("a", "b", "c");
List<Integer> mappedList = list.stream().map(String::length).collect(Collectors.toList());
System.out.println(mappedList); // 输出：[1, 1, 1]
26. 新的集合归约
Java 8提供了新的集合归约方法，如List.reduce()和Set.reduce()，使得集合归约更加方便。以下是一个使用新的集合归约的例子：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum); // 输出：15
27. 新的集合收集器
Java 8提供了新的集合收集器，如Collectors.toList()和Collectors.toSet()，使得集合收集更加方便。以下是一个使用新的集合收集器的例子：
List<String> list = Arrays.asList("a", "b", "c");
List<String> collectedList = list.stream().collect(Collectors.toList());
System.out.println(collectedList); // 输出：[a, b, c]
28. 新的集合分组
Java 8提供了新的集合分组方法，如List.groupBy()和Set.groupBy()，使得集合分组更加方便。以下是一个使用新的集合分组的例子：
List<String> list = Arrays.asList("a", "b", "c", "a", "b", "c");
Map<String, List<String>> groupedMap = list.stream().collect(Collectors.groupingBy(String::toString));
System.out.println(groupedMap); // 输出：{a=[a, a], b=[b, b], c=[c, c]}
29. 新的集合聚合
Java 8提供了新的集合聚合方法，如List.aggregate()和Set.aggregate()，使得集合聚合更加方便。以下是一个使用新的集合聚合的例子：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println(sum); // 输出：15
30. 新的集合连接
Java 8提供了新的集合连接方法，如List.flatMap()和Set.flatMap()，使得集合连接更加方便。以下是一个使用新的集合连接的例子：
List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("d", "e", "f");
List<String> flattenedList = list1.stream().flatMap(s -> list2.stream().map(s::concat)).collect(Collectors.toList());
System.out.println(flattenedList); // 输出：[ad, ae, af, bd, be, bf, cd, ce, cf]
通过以上30个实用案例，相信你已经对Java 8的新特性有了更深入的了解。希望这些案例能够帮助你轻松上手Java 8，提高你的编程效率。