【Java进阶篇】——第11篇：Java 8 新特性及使用

第11篇：Java 8 新特性及使用

Java 8 是一次里程碑式的更新，引入了多项革新特性，极大地提升了开发效率和代码表现力。本文将从 Lambda表达式、Stream API、时间日期API、Optional类 等核心特性出发，结合实战场景和最佳实践，全面解析Java 8的核心功能。

---

1. Lambda表达式与函数式编程

1.1 Lambda表达式基础

Lambda表达式允许以简洁的语法实现函数式接口（仅含一个抽象方法的接口），替代传统的匿名内部类。

语法结构：

(参数列表) -> { 代码逻辑 }

示例：线程创建对比

// 传统写法
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}).start();

// Lambda简化
new Thread(() -> System.out.println("Thread running")).start();

1.2 函数式接口

Java 8 内置了四大核心函数式接口：

• Consumer<T>：接收一个参数，无返回值。

  Consumer<String> print = s -> System.out.println(s);
  print.accept("Hello");
  

• Supplier<T>：无参数，返回一个值。

  Supplier<Double> random = Math::random;
  System.out.println(random.get());
  

• Function<T, R>：接收T类型参数，返回R类型。

  Function<String, Integer> length = String::length;
  System.out.println(length.apply("Java")); // 4
  

• Predicate<T>：接收T类型参数，返回布尔值。

  Predicate<Integer> isEven = n -> n % 2 == 0;
  System.out.println(isEven.test(4)); // true
  

1.3 方法引用

进一步简化Lambda表达式：

• 静态方法引用：ClassName::staticMethod

  List<Integer> numbers = Arrays.asList(1, 2, 3);
  numbers.forEach(System.out::println);
  

• 实例方法引用：instance::method

  String str = "Java";
  Supplier<Integer> length = str::length;
  

• 构造器引用：ClassName::new

  Supplier<List<String>> listSupplier = ArrayList::new;
  

---

2. Stream API

Stream API 提供了一种声明式处理集合数据的方式，支持顺序和并行操作，极大简化了集合处理。

2.1 Stream操作分类

• 中间操作：返回新Stream，延迟执行（如filter, map, sorted）。
• 终端操作：触发计算，关闭Stream（如forEach, collect, count）。

示例：集合处理

List<String> languages = Arrays.asList("Java", "Python", "C++", "Go");

// 过滤长度>3，转大写，排序，收集为List
List<String> result = languages.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
// 输出：[C++, GO, JAVA, PYTHON]

2.2 并行流加速处理

通过parallelStream()利用多核CPU提升性能：

List<Integer> numbers = IntStream.range(1, 10_000_000).boxed().collect(Collectors.toList());

// 顺序流计算总和
long sum1 = numbers.stream().mapToLong(Integer::longValue).sum();

// 并行流计算总和
long sum2 = numbers.parallelStream().mapToLong(Integer::longValue).sum();

2.3 常用收集器（Collectors）

• 转换为集合：toList(), toSet(), toMap()
• 分组统计：groupingBy(), partitioningBy()
• 聚合计算：summingInt(), averagingDouble(), maxBy()

示例：统计单词频率

List<String> words = Arrays.asList("apple", "banana", "apple", "orange");
Map<String, Long> frequency = words.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
// 输出：{apple=2, orange=1, banana=1}

---

3. 时间日期API（java.time）

Java 8 全新的时间日期API解决了旧版Date和Calendar的设计缺陷，提供不可变、线程安全的类。

3.1 核心类

• LocalDate：日期（年月日）。

  LocalDate date = LocalDate.now(); // 当前日期
  LocalDate independenceDay = LocalDate.of(2023, Month.JULY, 4);
  

• LocalTime：时间（时分秒）。

  LocalTime time = LocalTime.parse("15:30:45");
  

• LocalDateTime：日期时间组合。

  LocalDateTime dateTime = LocalDateTime.of(2023, 12, 31, 23, 59);
  

• Duration：时间间隔（基于时间单位）。

  Duration duration = Duration.between(startTime, endTime);
  

• Period：日期间隔（基于年、月、日）。

  Period period = Period.between(startDate, endDate);
  

3.2 格式化与解析

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.parse("2023-08-25 14:30:00", formatter);
String formatted = dateTime.format(formatter); // "2023-08-25 14:30:00"

---

4. Optional类

Optional用于优雅处理null值，避免空指针异常（NPE）。

4.1 基本使用

Optional<String> optional = Optional.ofNullable(getName());

// 存在值时执行操作
optional.ifPresent(name -> System.out.println("Name: " + name));

// 提供默认值
String name = optional.orElse("Unknown");

// 抛出异常
String value = optional.orElseThrow(() -> new IllegalArgumentException("值不能为空"));

4.2 链式操作

Optional<User> user = Optional.ofNullable(getUser());
String street = user.map(User::getAddress)
                   .map(Address::getStreet)
                   .orElse("No street");

---

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

Java 8 允许接口包含默认方法和静态方法，增强接口的扩展能力。

5.1 默认方法

public interface Vehicle {
    void run();

    default void honk() {
        System.out.println("Beep beep!");
    }
}

public class Car implements Vehicle {
    @Override
    public void run() {
        System.out.println("Car is running");
    }
}

5.2 静态方法

public interface MathUtils {
    static int add(int a, int b) {
        return a + b;
    }
}

int sum = MathUtils.add(3, 5); // 8

---

6. 其他新特性

6.1 重复注解

允许在同一位置多次使用相同注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface Roles {
    Role[] value();
}

@Repeatable(Roles.class)
public @interface Role {
    String value();
}

@Role("admin")
@Role("user")
public class User { }

6.2 类型注解

注解可应用于任何类型（如泛型、方法返回值）：

List<@NonNull String> list = new ArrayList<>();

6.3 方法参数反射

通过Parameter类获取方法参数名（需编译时添加-parameters参数）：

public void printInfo(@NotNull String name, int age) {
    // ...
}

Method method = User.class.getMethod("printInfo", String.class, int.class);
Parameter[] parameters = method.getParameters();
System.out.println(parameters[0].getName()); // 输出name

---

7. 实战案例与最佳实践

案例1：使用Stream优化集合操作

// 传统写法
List<String> filteredNames = new ArrayList<>();
for (User user : users) {
    if (user.getAge() > 18) {
        filteredNames.add(user.getName());
    }
}

// Stream优化
List<String> filteredNames = users.stream()
    .filter(user -> user.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());

案例2：时间日期计算

LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plusDays(7);
Period period = Period.between(today, nextWeek);
System.out.println("间隔天数：" + period.getDays()); // 7

最佳实践：

1. 优先使用Lambda和Stream：简化代码，提升可读性。
2. 避免过度并行化：并行流适用于大数据量且无状态操作。
3. 时间处理使用java.time：替代Date和Calendar。
4. 善用Optional减少NPE：但避免滥用（如不要用于集合字段）。

---

8. 总结

Java 8 的革新特性为开发者提供了更强大的工具集：

• Lambda与Stream：函数式编程简化集合操作。
• 时间日期API：更安全、更直观的时间处理。
• Optional：优雅处理空值，减少NPE。
• 接口增强：默认方法与静态方法提升灵活性。

通过合理利用这些特性，可以显著提升代码质量、可维护性和性能。