Java 8 是一个里程碑式的版本，引入了许多激动人心的新特性，极大地提升了开发效率和代码可读性，并拥抱了函数式编程的思想。这些特性至今仍是Java开发者必须掌握的核心技能。本文将带你了解Java 8的主要新特性，并通过实例展示其强大之处。
1. Lambda 表达式 (Lambda Expressions)
Lambda表达式是Java 8最引人注目的特性之一。它提供了一种简洁的方式来表示匿名函数（即没有名称的函数），主要用于实现函数式接口（只有一个抽象方法的接口）。
核心思想： 将行为（代码块）作为参数传递给方法。
语法： (parameters) -> expression 或 (parameters) -> { statements; }
示例： 使用Lambda替代匿名内部类（如Runnable）
java
// Java 8 之前
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello from anonymous inner class!");
}
}).start();
// Java 8 使用 Lambda
new Thread(() -> System.out.println("Hello from Lambda!")).start();可以看到，Lambda让线程创建的代码变得异常简洁清晰。
2. 函数式接口 (Functional Interfaces)
函数式接口是Lambda表达式的基础。它是一个只包含一个 抽象方法的接口（可以有多个默认方法或静态方法）。Java 8 在java.util.function包中内置了许多常用的函数式接口，如：
Predicate<T>：代表一个判断条件（返回布尔值）。抽象方法：boolean test(T t)Function<T, R>：代表一个函数，接受T类型参数，返回R类型结果。抽象方法：R apply(T t)Consumer<T>：代表一个操作，接受T类型参数，无返回值。抽象方法：void accept(T t)Supplier<T>：代表一个提供者，无参数，返回T类型结果。抽象方法：T get()
示例： 使用Predicate过滤集合
java
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class FunctionalInterfaceExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
// 使用 Predicate 定义过滤条件 (名字长度大于4)
Predicate<String> lengthGT4 = name -> name.length() > 4;
// 使用该 Predicate 进行过滤 (传统方式遍历)
for (String name : names) {
if (lengthGT4.test(name)) {
System.out.println(name);
}
}
// 输出: Charlie, David
}
}3. 方法引用 (Method References)
方法引用是Lambda表达式的一种更简洁的写法，用于直接引用已有方法。它只是语法糖，底层仍然是Lambda。
语法形式：
- 静态方法引用：
ClassName::staticMethodName - 实例方法引用：
objectReference::instanceMethodName - 特定类型任意对象的实例方法引用：
ClassName::instanceMethodName(第一个参数是调用者) - 构造方法引用：
ClassName::new
示例： 结合Consumer使用
java
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class MethodReferenceExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// Lambda 表达式
names.forEach(name -> System.out.println(name));
// 方法引用 (引用 System.out 的 println 方法)
names.forEach(System.out::println);
}
}方法引用让代码意图更加明确。
4. Stream API
Stream API 是处理集合数据的强大工具。它提供了一种声明式、高效且可并行处理数据的方式。
核心概念：
- Stream： 代表数据流，本身不存储数据，数据源可以是集合、数组、I/O通道等。
- 操作： 分为中间操作（如
filter,map,sorted）和终止操作（如forEach,collect,count）。中间操作返回新的Stream，形成流水线；终止操作触发计算并产生结果或副作用。 - 特点： 延迟执行（只有遇到终止操作才执行）、内部迭代（开发者无需关心循环）。
示例： 过滤、转换、收集
java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
// 1. 过滤出长度大于3的名字
// 2. 将名字转换为大写
// 3. 收集到一个新的List中
List<String> result = names.stream() // 获取流
.filter(name -> name.length() > 3) // 中间操作: 过滤
.map(String::toUpperCase) // 中间操作: 映射 (使用方法引用)
.collect(Collectors.toList()); // 终止操作: 收集
System.out.println(result); // 输出: [ALICE, CHARLIE, DAVID, EVE]
}
}Stream API 极大地简化了集合操作，代码可读性高。
5. 默认方法 (Default Methods)
默认方法允许在接口中提供具有默认实现的方法。这使得在向现有接口添加新方法时，不会破坏所有已有的实现类。
语法： 在接口中使用default关键字修饰方法。
示例：
java
public interface Vehicle {
// 传统抽象方法
void start();
// Java 8 默认方法
default void honk() {
System.out.println("Beep beep!");
}
}
public class Car implements Vehicle {
@Override
public void start() {
System.out.println("Car started.");
}
// 不需要实现 honk(), 使用默认实现
}
public class DefaultMethodExample {
public static void main(String[] args) {
Car myCar = new Car();
myCar.start(); // 输出: Car started.
myCar.honk(); // 输出: Beep beep! (调用接口默认方法)
}
}6. Optional 类
Optional<T>是一个容器对象，用于包装可能为null的值。它旨在更优雅地处理NullPointerException，鼓励开发者显式检查值是否存在。
核心方法：
Optional.of(T value): 创建一个包含非null值的Optional。Optional.ofNullable(T value): 创建一个Optional，值可以是null。isPresent(): 检查值是否存在。get(): 获取值（如果存在），否则抛出NoSuchElementException。orElse(T other): 如果值存在则返回，否则返回other。ifPresent(Consumer<T> consumer): 如果值存在，则执行给定的消费操作。
示例： 安全获取可能为null的值
java
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
// 模拟一个可能返回null的方法
String potentialNull = getStringFromSomewhere();
// 传统方式 (易引发 NullPointerException)
// System.out.println(potentialNull.length());
// 使用 Optional
Optional<String> opt = Optional.ofNullable(potentialNull);
// 方式1: 检查存在性
if (opt.isPresent()) {
System.out.println(opt.get().length());
} else {
System.out.println("No value present");
}
// 方式2: 使用 orElse 提供默认值
String safeValue = opt.orElse("Default String");
System.out.println(safeValue.length());
// 方式3: 如果存在则执行操作 (更函数式)
opt.ifPresent(val -> System.out.println(val.length()));
}
private static String getStringFromSomewhere() {
// 模拟有时返回null
return Math.random() > 0.5 ? "Hello" : null;
}
}7. 新的日期时间 API (Date/Time API)
Java 8 引入了全新的 java.time 包，解决了旧的 java.util.Date 和 java.util.Calendar 类的诸多问题（如可变性、API设计混乱、线程不安全）。新API是不可变的、线程安全的，并且设计清晰。
核心类：
LocalDate: 只包含日期（年、月、日）。LocalTime: 只包含时间（时、分、秒、纳秒）。LocalDateTime: 包含日期和时间。ZonedDateTime: 包含日期、时间和时区信息。Instant: 时间戳（从UTC 1970年1月1日开始的纳秒数）。Duration: 时间段（基于时间的，如秒、纳秒）。Period: 时间段（基于日期的，如年、月、日）。
示例： 计算日期和操作时间
java
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.temporal.ChronoUnit;
public class DateTimeExample {
public static void main(String[] args) {
// 获取当前日期
LocalDate today = LocalDate.now();
System.out.println("Today: " + today); // 输出如: 2023-10-27
// 创建特定日期
LocalDate birthday = LocalDate.of(1990, Month.MAY, 15);
System.out.println("Birthday: " + birthday);
// 计算两个日期之间的天数差
long daysBetween = ChronoUnit.DAYS.between(birthday, today);
System.out.println("Days since birthday: " + daysBetween);
// 操作日期 (加/减)
LocalDate nextWeek = today.plusDays(7);
System.out.println("Next week: " + nextWeek);
// 获取当前日期时间
LocalDateTime now = LocalDateTime.now();
System.out.println("Now: " + now); // 输出如: 2023-10-27T14:30:15.123
}
}总结
Java 8 的新特性，特别是 Lambda表达式 、函数式接口 、方法引用 和 Stream API ，彻底改变了Java的编程范式，使其能够更加简洁、高效、声明式地处理数据和行为。默认方法 增强了接口的灵活性，Optional 提供了更安全的null值处理方式，而全新的日期时间API则解决了长久以来的痛点。
掌握这些特性是成为一名现代Java开发者的关键。它们不仅提升了代码质量和开发效率，也为Java注入了新的活力。希望本文的示例能帮助你更好地理解和应用这些强大的工具！