Java 8 新特性详解

2024年3月22日 · 阅读需 14 分钟

架构师

Java 8 是 Java 语言开发的一个重要版本，发布于2014年3月18日。这个版本包含了许多重要的新特性，极大地提升了Java语言的能力和开发效率。让我们一起来了解Java 8的主要新特性。

1. Lambda 表达式

Lambda表达式是Java 8中最重要的新特性之一，它允许我们将行为像数据一样进行传递。Lambda表达式本质上是一个匿名函数，可以更简洁地表示只有一个抽象方法的接口（函数式接口）的实现。

示例代码：

// 传统方式
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World!");
    }
};

// Lambda表达式
Runnable runnable = () -> System.out.println("Hello World!");
java

主要特点：

函数式编程支持
简化代码编写
提高代码可读性
支持并行操作

2. 函数式接口

函数式接口是只包含一个抽象方法的接口。Java 8引入了@FunctionalInterface注解来标记函数式接口。常用的函数式接口包括：

Predicate<T>: 接收参数T，返回boolean
Consumer<T>: 接收参数T，无返回值
Function<T,R>: 接收参数T，返回R
Supplier<T>: 无参数，返回T

示例：

Predicate<String> isEmpty = str -> str.isEmpty();
Consumer<String> printer = str -> System.out.println(str);
Function<String, Integer> toInt = str -> Integer.parseInt(str);
Supplier<String> getter = () -> "Hello World";
java

3. Stream API

Stream API提供了一种新的数据处理方式，可以通过串行或并行的方式对集合进行复杂的操作。Stream API支持链式调用，使代码更加简洁易读。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .forEach(System.out::println);
java

4. Optional类

Optional类是一个可以为null的容器对象，用于避免空指针异常。它提供了很多有用的方法来处理可能为null的对象。

示例：

Optional<String> optional = Optional.of("Hello");
String result = optional.orElse("World");
optional.ifPresent(str -> System.out.println(str));
java

5. 新的日期时间API

Java 8引入了新的日期时间API（java.time包），这些API提供了更好的日期和时间处理功能：

// 获取当前日期
LocalDate today = LocalDate.now();
// 获取当前时间
LocalTime time = LocalTime.now();
// 获取当前日期时间
LocalDateTime dateTime = LocalDateTime.now();
// 日期计算
LocalDate tomorrow = today.plusDays(1);
java

6. 接口的默认方法和静态方法

Java 8允许在接口中定义默认方法和静态方法，这样可以在不破坏现有实现的情况下向接口添加新的方法。

interface MyInterface {
    // 默认方法
    default void defaultMethod() {
        System.out.println("Default method");
    }
    
    // 静态方法
    static void staticMethod() {
        System.out.println("Static method");
    }
}
java

7. 方法引用

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

静态方法引用：ClassName::staticMethodName
实例方法引用：instance::methodName
对象方法引用：ClassName::methodName
构造方法引用：ClassName::new

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);
java

8. Nashorn JavaScript引擎

Java 8引入了全新的JavaScript引擎Nashorn，替代了旧的Rhino引擎。Nashorn提供了更好的性能和更完整的ECMAScript支持。

8.1 主要特性

提供了更好的性能（比Rhino快5-10倍）
支持ECMAScript 5.1规范
提供了Java和JavaScript的无缝集成
支持命令行工具jjs

示例代码：

// 使用ScriptEngineManager
ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
engine.eval("print('Hello World from Nashorn');");

// 在JavaScript中调用Java代码
engine.eval("var ArrayList = Java.type('java.util.ArrayList');" +
           "var list = new ArrayList();" +
           "list.add('Hello');" +
           "list.add('World');" +
           "print(list);");
java

命令行使用示例：

# 运行JavaScript文件
jjs script.js

# 交互式Shell
jjs
>> var greeting = "Hello World"
>> print(greeting)
bash

9. 并行数组操作

Java 8为数组操作提供了新的并行处理能力，显著提升了性能。

9.1 并行排序

Arrays类新增了并行排序算法，可以充分利用多核处理器：

// 并行排序
int[] numbers = {5, 3, 8, 1, 9, 4};
Arrays.parallelSort(numbers);

// 部分排序
int[] largeArray = new int[10000];
Arrays.parallelSort(largeArray, 0, 5000); // 只排序前5000个元素
java

9.2 并行数组操作

Arrays类还提供了许多并行操作方法：

int[] array = new int[10000];

// 并行设置数组元素
Arrays.parallelSetAll(array, i -> i * 2);

// 并行前缀操作
Arrays.parallelPrefix(array, (x, y) -> x + y);
java

10. Base64编码

Java 8在java.util包中添加了内置的Base64编码支持：

// 基本编码
String text = "Hello World!";
String encoded = Base64.getEncoder().encodeToString(text.getBytes());
String decoded = new String(Base64.getDecoder().decode(encoded));

// URL安全编码
String urlEncoded = Base64.getUrlEncoder().encodeToString(text.getBytes());
String urlDecoded = new String(Base64.getUrlDecoder().decode(urlEncoded));

// MIME编码
String mimeEncoded = Base64.getMimeEncoder().encodeToString(text.getBytes());
String mimeDecoded = new String(Base64.getMimeDecoder().decode(mimeEncoded));
java

11. 并发性改进

Java 8在并发处理方面也做了重要改进：

11.1 StampedLock

新增的StampedLock提供了一种乐观读锁的实现，这种锁比传统的读写锁性能更好：

StampedLock lock = new StampedLock();

// 写锁
long stamp = lock.writeLock();
try {
    // 写入共享数据
} finally {
    lock.unlockWrite(stamp);
}

// 乐观读
long stamp = lock.tryOptimisticRead();
// 读取共享数据
if (!lock.validate(stamp)) {
    // 如果数据已被修改，获取悲观读锁
    stamp = lock.readLock();
    try {
        // 重新读取数据
    } finally {
        lock.unlockRead(stamp);
    }
}
java

11.2 CompletableFuture

CompletableFuture提供了强大的异步编程支持：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步操作
    return "Hello";
}).thenApply(s -> {
    // 转换结果
    return s + " World";
}).thenAccept(System.out::println);
java

12. 新的集合API增强

Java 8对集合API进行了多项增强，使集合操作更加便捷和高效。

12.1 Map接口的新方法

Map接口新增了多个默认方法，使得操作Map更加方便：

Map<String, String> map = new HashMap<>();

// 计算
map.compute("key", (k, v) -> v == null ? "default" : v + "new");

// 不存在时计算
map.computeIfAbsent("key", k -> "value");

// 存在时计算
map.computeIfPresent("key", (k, v) -> v + "new");

// 合并
map.merge("key", "value", (oldVal, newVal) -> oldVal + newVal);

// 获取值，如果key不存在返回默认值
String value = map.getOrDefault("key", "default");

// 遍历
map.forEach((k, v) -> System.out.println(k + ":" + v));

// 替换所有值
map.replaceAll((k, v) -> v.toUpperCase());
java

12.2 List接口的新方法

List接口也添加了一些实用的默认方法：

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

// 批量添加元素
list.addAll(Arrays.asList("a", "b", "c"));

// 替换所有元素
list.replaceAll(String::toUpperCase);

// 根据条件删除元素
list.removeIf(s -> s.equals("A"));

// 排序
list.sort(Comparator.naturalOrder());
java

12.3 Collection接口的新方法

Collection接口新增了一些通用的默认方法：

Collection<String> collection = new ArrayList<>();

// 添加多个元素
collection.addAll(Arrays.asList("a", "b", "c"));

// 转换为Stream
Stream<String> stream = collection.stream();

// 转换为并行Stream
Stream<String> parallelStream = collection.parallelStream();

// 删除满足条件的元素
collection.removeIf(s -> s.isEmpty());
java

12.4 Collectors类的增强

Collectors工具类提供了更多强大的收集器：

List<String> list = Arrays.asList("apple", "banana", "orange", "apple");

// 收集到List
List<String> collected = list.stream()
    .collect(Collectors.toList());

// 收集到Set（去重）
Set<String> unique = list.stream()
    .collect(Collectors.toSet());

// 收集到Map
Map<String, Integer> lengthMap = list.stream()
    .collect(Collectors.toMap(
        s -> s,
        String::length,
        (existing, replacement) -> existing // 处理重复key
    ));

// 分组
Map<Integer, List<String>> groupByLength = list.stream()
    .collect(Collectors.groupingBy(String::length));

// 连接字符串
String joined = list.stream()
    .collect(Collectors.joining(", "));

// 计算统计信息
IntSummaryStatistics stats = list.stream()
    .collect(Collectors.summarizingInt(String::length));
java

12.5 不可变集合工厂方法

Java 8提供了创建小型不可变集合的便捷方法：

// 创建不可变List
List<String> immutableList = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

// 创建不可变Set
Set<String> immutableSet = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));

// 创建不可变Map
Map<String, Integer> immutableMap = Collections.unmodifiableMap(new HashMap<String, Integer>() {{
    put("a", 1);
    put("b", 2);
    put("c", 3);
}});
java

这些集合API的增强大大提高了开发效率，使得代码更加简洁和易读。结合Stream API，可以实现更加复杂的集合操作。

13. JVM优化

Java 8在JVM层面也进行了大量优化，主要包括以下几个方面：

13.1 元空间（Metaspace）

Java 8 移除了永久代（PermGen），取而代之的是元空间（Metaspace）。这是一个显著的变化：

元空间并不在虚拟机中，而是使用本地内存
默认情况下，元空间大小仅受本地内存限制
减少了java.lang.OutOfMemoryError: PermGen space错误
可以通过参数-XX:MetaspaceSize和-XX:MaxMetaspaceSize来指定元空间大小

13.2 垃圾回收（GC）优化

并行垃圾回收器改进

提供了更多的垃圾回收器选择
改进了G1垃圾回收器，使其能够更好地处理大堆内存
优化了垃圾回收的性能和暂停时间

示例JVM参数配置：

# 使用G1垃圾回收器
-XX:+UseG1GC
# 设置目标暂停时间
-XX:MaxGCPauseMillis=200
# 设置元空间初始大小和最大大小
-XX:MetaspaceSize=256m
-XX:MaxMetaspaceSize=512m
bash

13.3 JIT编译器优化

改进了JIT编译器，提供更好的性能优化
增强了方法内联
改进了逃逸分析
优化了字符串连接操作
提供了更好的Lambda表达式编译支持

13.4 内存管理优化

改进了内存分配策略
优化了线程本地分配缓冲区（TLAB）
提供了更好的大对象处理机制
改进了数组和字符串的内存布局

13.5 新的性能诊断工具

Java 8提供了一些新的性能诊断和监控工具：

jdeps：新的Java类依赖性分析器
jjs：Nashorn引擎的命令行工具
改进的jmap和jstack工具

性能调优示例：

# 查看类依赖关系
jdeps MyApp.jar

# 生成堆转储
jmap -dump:format=b,file=heap.bin <pid>

# 查看线程状态
jstack <pid>
bash

总结

Java 8引入的这些新特性大大提升了Java语言的表达能力和开发效率。Lambda表达式和Stream API使得函数式编程在Java中成为可能，新的日期时间API解决了旧版API的诸多问题，Optional类帮助我们更好地处理null值，接口的默认方法让接口更加灵活。这些特性的引入使Java更加现代化，也为未来版本的发展奠定了基础。

要充分利用这些新特性，建议：

多使用Lambda表达式简化代码
使用Stream API进行集合操作
使用Optional避免空指针异常
使用新的日期时间API替代旧的API
合理使用接口默认方法
适当使用方法引用提高代码可读性
合理配置JVM参数以优化性能
使用新的诊断工具进行性能分析和调优
使用Nashorn引擎实现Java和JavaScript的混合编程
利用并行数组操作提升性能
使用新的并发工具改进应用性能
合理使用Base64编码处理二进制数据

通过合理运用这些特性，我们可以写出更加简洁、高效、易维护的代码。同时，借助JVM层面的优化，还能获得更好的运行时性能。

1. Lambda 表达式​

2. 函数式接口​

3. Stream API​

4. Optional类​

5. 新的日期时间API​

6. 接口的默认方法和静态方法​

7. 方法引用​

8. Nashorn JavaScript引擎​

8.1 主要特性​

9. 并行数组操作​

9.1 并行排序​

9.2 并行数组操作​

10. Base64编码​

11. 并发性改进​

11.1 StampedLock​

11.2 CompletableFuture​

12. 新的集合API增强​

12.1 Map接口的新方法​

12.2 List接口的新方法​

12.3 Collection接口的新方法​

12.4 Collectors类的增强​

12.5 不可变集合工厂方法​

13. JVM优化​

13.1 元空间（Metaspace）​

13.2 垃圾回收（GC）优化​

并行垃圾回收器改进​

13.3 JIT编译器优化​

13.4 内存管理优化​

13.5 新的性能诊断工具​

总结​