Java 8作为Java发展历程中的一个重要里程碑，引入了众多创新特性，极大地丰富了Java语言的表达能力和开发效率。本文将详细介绍Java 8的30个实战案例，帮助读者轻松上手，快速掌握这些核心技术。
1. Lambda表达式
Lambda表达式是Java 8的一大亮点，它允许开发者以更简洁的方式编写函数式接口。以下是一个使用Lambda表达式计算两个整数之和的例子：
interface BinaryOperator<T> {
T apply(T a, T b);
}
public class LambdaExample {
public static void main(String[] args) {
BinaryOperator<Integer> add = (a, b) -> a + b;
System.out.println(add.apply(10, 20)); // 输出：30
}
}
2. Stream API
Stream API是Java 8引入的一种新的抽象层，用于处理集合数据。以下是一个使用Stream API计算集合中所有元素平方的例子：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = numbers.stream().map(n -> n * n).collect(Collectors.toList());
System.out.println(squares); // 输出：[1, 4, 9, 16, 25]
3. 方法引用
方法引用是Lambda表达式的一种简写形式，它可以让我们以更简洁的方式引用现有方法。以下是一个使用方法引用的例子：
public class MethodReferenceExample {
public static void main(String[] args) {
Consumer<String> consumer = System.out::println;
consumer.accept("Hello, World!"); // 输出：Hello, World!
}
}
4. 默认方法
默认方法允许接口添加新的方法，而不需要修改实现该接口的所有类。以下是一个使用默认方法的例子：
interface Animal {
void eat();
default void sleep() {
System.out.println("Zzz...");
}
}
class Dog implements Animal {
public void eat() {
System.out.println("Dog is eating");
}
}
public class DefaultMethodExample {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // 输出：Dog is eating
dog.sleep(); // 输出：Zzz...
}
}
5. Date-Time API
Java 8引入了全新的Date-Time API，用于处理日期和时间。以下是一个使用Date-Time API获取当前日期的例子：
LocalDate today = LocalDate.now();
System.out.println(today); // 输出：当前日期
6. Optional类
Optional类用于避免空指针异常，它允许我们以更安全的方式处理可能为null的对象。以下是一个使用Optional类的例子：
Optional<String> optional = Optional.ofNullable(null);
System.out.println(optional.orElse("Default Value")); // 输出：Default Value
7. CompletionService
CompletionService允许我们以异步方式处理多个任务，并按完成顺序获取结果。以下是一个使用CompletionService的例子：
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletionService<String> completionService = new ExecutorCompletionService<>(executor);
completionService.submit(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 1";
});
completionService.submit(() -> {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 2";
});
for (int i = 0; i < 2; i++) {
Future<String> future = completionService.take();
System.out.println(future.get());
}
8. CompletableFuture
CompletableFuture允许我们以异步方式执行多个任务，并按完成顺序获取结果。以下是一个使用CompletableFuture的例子：
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 1";
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 2";
});
CompletableFuture.allOf(future1, future2).join();
System.out.println(future1.join() + ", " + future2.join()); // 输出：Task 2, Task 1
9. 接口中的私有方法
Java 8允许在接口中定义私有方法，这些私有方法可以在接口的实现中使用。以下是一个使用接口私有方法的例子：
interface Animal {
void eat();
default void sleep() {
System.out.println("Zzz...");
doSleep();
}
private void doSleep() {
System.out.println("Deep sleep...");
}
}
class Dog implements Animal {
public void eat() {
System.out.println("Dog is eating");
}
}
public class PrivateMethodExample {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // 输出：Dog is eating
dog.sleep(); // 输出：Zzz... Deep sleep...
}
}
10. 标准化流操作
Java 8引入了标准化流操作，使得集合操作更加简洁。以下是一个使用标准化流操作的例子：
List<String> words = Arrays.asList("Java", "8", "new", "features");
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperCaseWords); // 输出：[JAVA, 8, NEW, FEATURES]
11. 引入新的数据类型
Java 8引入了新的数据类型，如LongBitField和LongBlob等，这些数据类型可以用于存储和处理大数据。以下是一个使用LongBitField的例子：
LongBitField bitField = new LongBitField(10);
System.out.println(bitField.get(3)); // 输出：0
bitField.set(3, 1);
System.out.println(bitField.get(3)); // 输出：1
12. 新的日期和时间格式化工具
Java 8引入了新的日期和时间格式化工具，如DateTimeFormatter和ZonedDateTime等，这些工具可以更方便地处理日期和时间。以下是一个使用DateTimeFormatter的例子：
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);
System.out.println(formattedDate); // 输出：当前日期的格式化字符串
13. 新的并发工具
Java 8引入了新的并发工具，如CompletableFuture和CompletableFutureExecutor等，这些工具可以更方便地处理并发任务。以下是一个使用CompletableFutureExecutor的例子：
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFutureExecutor<String> completableFutureExecutor = new CompletableFutureExecutor<>(executor);
CompletableFuture<String> future = completableFutureExecutor.submit(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task";
});
System.out.println(future.get()); // 输出：Task
14. 新的集合操作
Java 8引入了新的集合操作，如flatMap和mapToObj等，这些操作可以更方便地处理集合数据。以下是一个使用flatMap的例子：
List<List<String>> lists = Arrays.asList(
Arrays.asList("Java", "8"),
Arrays.asList("new", "features")
);
List<String> flattenedList = lists.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
System.out.println(flattenedList); // 输出：[Java, 8, new, features]
15. 新的文件操作
Java 8引入了新的文件操作，如Files和Paths等，这些操作可以更方便地处理文件和目录。以下是一个使用Files的例子：
Path path = Paths.get("example.txt");
try (BufferedReader reader = Files.newBufferedReader(path)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
16. 新的集合类
Java 8引入了新的集合类，如Stream和Optional等，这些集合类可以更方便地处理集合数据。以下是一个使用Stream的例子：
List<String> words = Arrays.asList("Java", "8", "new", "features");
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperCaseWords); // 输出：[JAVA, 8, NEW, FEATURES]
17. 新的日期和时间格式化工具
Java 8引入了新的日期和时间格式化工具，如DateTimeFormatter和ZonedDateTime等，这些工具可以更方便地处理日期和时间。以下是一个使用DateTimeFormatter的例子：
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);
System.out.println(formattedDate); // 输出：当前日期的格式化字符串
18. 新的并发工具
Java 8引入了新的并发工具，如CompletableFuture和CompletableFutureExecutor等，这些工具可以更方便地处理并发任务。以下是一个使用CompletableFutureExecutor的例子：
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFutureExecutor<String> completableFutureExecutor = new CompletableFutureExecutor<>(executor);
CompletableFuture<String> future = completableFutureExecutor.submit(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task";
});
System.out.println(future.get()); // 输出：Task
19. 新的集合操作
Java 8引入了新的集合操作，如flatMap和mapToObj等，这些操作可以更方便地处理集合数据。以下是一个使用flatMap的例子：
List<List<String>> lists = Arrays.asList(
Arrays.asList("Java", "8"),
Arrays.asList("new", "features")
);
List<String> flattenedList = lists.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
System.out.println(flattenedList); // 输出：[Java, 8, new, features]
20. 新的文件操作
Java 8引入了新的文件操作，如Files和Paths等，这些操作可以更方便地处理文件和目录。以下是一个使用Files的例子：
Path path = Paths.get("example.txt");
try (BufferedReader reader = Files.newBufferedReader(path)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
21. 新的集合类
Java 8引入了新的集合类，如Stream和Optional等，这些集合类可以更方便地处理集合数据。以下是一个使用Stream的例子：
List<String> words = Arrays.asList("Java", "8", "new", "features");
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperCaseWords); // 输出：[JAVA, 8, NEW, FEATURES]
22. 新的日期和时间格式化工具
Java 8引入了新的日期和时间格式化工具，如DateTimeFormatter和ZonedDateTime等，这些工具可以更方便地处理日期和时间。以下是一个使用DateTimeFormatter的例子：
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);
System.out.println(formattedDate); // 输出：当前日期的格式化字符串
23. 新的并发工具
Java 8引入了新的并发工具，如CompletableFuture和CompletableFutureExecutor等，这些工具可以更方便地处理并发任务。以下是一个使用CompletableFutureExecutor的例子：
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFutureExecutor<String> completableFutureExecutor = new CompletableFutureExecutor<>(executor);
CompletableFuture<String> future = completableFutureExecutor.submit(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task";
});
System.out.println(future.get()); // 输出：Task
24. 新的集合操作
Java 8引入了新的集合操作，如flatMap和mapToObj等，这些操作可以更方便地处理集合数据。以下是一个使用flatMap的例子：
List<List<String>> lists = Arrays.asList(
Arrays.asList("Java", "8"),
Arrays.asList("new", "features")
);
List<String> flattenedList = lists.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
System.out.println(flattenedList); // 输出：[Java, 8, new, features]
25. 新的文件操作
Java 8引入了新的文件操作，如Files和Paths等，这些操作可以更方便地处理文件和目录。以下是一个使用Files的例子：
Path path = Paths.get("example.txt");
try (BufferedReader reader = Files.newBufferedReader(path)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
26. 新的集合类
Java 8引入了新的集合类，如Stream和Optional等，这些集合类可以更方便地处理集合数据。以下是一个使用Stream的例子：
List<String> words = Arrays.asList("Java", "8", "new", "features");
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperCaseWords); // 输出：[JAVA, 8, NEW, FEATURES]
27. 新的日期和时间格式化工具
Java 8引入了新的日期和时间格式化工具，如DateTimeFormatter和ZonedDateTime等，这些工具可以更方便地处理日期和时间。以下是一个使用DateTimeFormatter的例子：
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);
System.out.println(formattedDate); // 输出：当前日期的格式化字符串
28. 新的并发工具
Java 8引入了新的并发工具，如CompletableFuture和CompletableFutureExecutor等，这些工具可以更方便地处理并发任务。以下是一个使用CompletableFutureExecutor的例子：
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFutureExecutor<String> completableFutureExecutor = new CompletableFutureExecutor<>(executor);
CompletableFuture<String> future = completableFutureExecutor.submit(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task";
});
System.out.println(future.get()); // 输出：Task
29. 新的集合操作
Java 8引入了新的集合操作，如flatMap和mapToObj等，这些操作可以更方便地处理集合数据。以下是一个使用flatMap的例子：
List<List<String>> lists = Arrays.asList(
Arrays.asList("Java", "8"),
Arrays.asList("new", "features")
);
List<String> flattenedList = lists.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
System.out.println(flattenedList); // 输出：[Java, 8, new, features]
30. 新的文件操作
Java 8引入了新的文件操作，如Files和Paths等，这些操作可以更方便地处理文件和目录。以下是一个使用Files的例子：
Path path = Paths.get("example.txt");
try (BufferedReader reader = Files.newBufferedReader(path)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
通过以上30个实战案例，相信读者已经对Java 8的新特性有了更深入的了解。希望这些案例能够帮助读者轻松上手，快速掌握Java 8的核心技术。