深入理解 JDK 1.8 新特性

JDK 1.8（Java 8）引入了许多新的特性和改进，极大地提升了 Java 开发的便捷性和效率。以下是 JDK 1.8 的主要新特性及其详细介绍：

1. Lambda 表达式

Lambda 表达式提供了一种简洁的代码表达方式，可以替代匿名内部类，特别适用于对集合进行迭代和操作。Lambda 表达式的语法如下：

(parameters) -> expression
或
(parameters) -> { statements; }

示例：

// 使用匿名内部类
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from thread");
    }
}).start();

// 使用 Lambda 表达式
new Thread(() -> System.out.println("Hello from thread")).start();

// 示例：对列表进行排序
List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

// 传统方式
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// 使用 Lambda 表达式
Collections.sort(names, (String a, String b) -> {
    return a.compareTo(b);
});

// 更简洁的 Lambda 表达式
Collections.sort(names, (a, b) -> a.compareTo(b));

Lambda 表达式的引入使得代码更简洁，尤其是在处理集合和并发操作时，显著提升了代码的可读性和维护性。

函数式接口

函数式接口是只包含一个抽象方法的接口，通常用于 Lambda 表达式和方法引用。Java 8 引入了 java.util.function 包，包含许多内置的函数式接口，如 Function, Predicate, Supplier, Consumer。

示例：

// 示例：使用 Predicate 进行过滤
List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");
Predicate<String> startsWithP = (n) -> n.startsWith("P");
names.stream().filter(startsWithP).forEach(System.out::println); // 输出：Peter

3. 方法引用

方法引用是对 Lambda 表达式的进一步简化，使用 :: 符号来引用类的方法或构造函数。方法引用使代码更加简洁和易读。

示例：

// 使用 Lambda 表达式
Arrays.sort(arr, (a, b) -> a.compareToIgnoreCase(b));

// 使用方法引用
Arrays.sort(arr, String::compareToIgnoreCase);

方法引用的四种形式：

引用静态方法：ClassName::staticMethod
引用特定对象的实例方法：instance::instanceMethod
引用特定类型的任意对象的实例方法：ClassName::instanceMethod
引用构造函数：ClassName::new

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

Java 8 允许在接口中定义默认方法和静态方法。默认方法使用 default 关键字定义，提供了接口的默认实现。静态方法则通过 static 关键字定义，可以直接在接口上调用。

示例：

interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method");
    }

    static void staticMethod() {
        System.out.println("This is a static method");
    }
}

class MyClass implements MyInterface {}

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.defaultMethod(); // 调用默认方法

        MyInterface.staticMethod(); // 调用静态方法
    }
}

5. Stream API

Stream API 为集合框架提供了一种新的处理数据的抽象，可以以声明性方式处理数据流。Stream API 支持串行和并行操作，极大地简化了集合操作和并发处理。

示例：

List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
      .filter(s -> s.startsWith("c"))
      .map(String::toUpperCase)
      .sorted()
      .forEach(System.out::println); // 输出：C1 C2

Stream API 的操作分为中间操作和终端操作：

中间操作：返回新的 Stream，如 filter、map、sorted。
终端操作：生成结果或副作用，如 forEach、collect、reduce。

6. Optional 类

Optional 类用于解决空指针异常问题，它是一个容器类，代表一个值存在或不存在。Optional 提供了多种方法来处理可能为空的值，避免显式的空值检查。

示例：

Optional<String> optional = Optional.of("Hello");
optional.ifPresent(System.out::println); // 输出 "Hello"

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElse("Default Value")); // 输出 "Default Value"

Optional 类的主要方法：

of：创建包含非空值的 Optional。
empty：创建空的 Optional。
ifPresent：如果值存在，执行给定的操作。
orElse：如果值存在，返回该值，否则返回默认值。

7. 新的日期和时间 API

Java 8 引入了全新的日期和时间 API（java.time 包），该 API 借鉴了 Joda-Time 库的设计，提供了更好的日期和时间处理方式。

示例：

// 示例：新的日期和时间 API
LocalDate today = LocalDate.now();
System.out.println(today); // 输出：当前日期

LocalDate birthday = LocalDate.of(1990, Month.JANUARY, 1);
System.out.println(birthday); // 输出：1990-01-01

// 计算两个日期之间的差异
Period period = Period.between(birthday, today);
System.out.println("Years: " + period.getYears()); // 输出年份差

新 API 的主要类：

LocalDate：表示无时区的日期。
LocalTime：表示无时区的时间。
LocalDateTime：表示无时区的日期时间。
ZonedDateTime：表示带时区的日期时间。
Period：表示两个日期之间的时间间隔。
Duration：表示两个时间点之间的时间长度。

8. Nashorn JavaScript 引擎

Nashorn 是 JDK 1.8 引入的全新 JavaScript 引擎，允许在 JVM 上运行 JavaScript 代码，并且与 Java 代码无缝集成。

示例：

// 示例：Nashorn JavaScript 引擎
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class NashornExample {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");

        String script = "var greeting = 'Hello, Nashorn'; greeting;";
        try {
            Object result = engine.eval(script);
            System.out.println(result); // 输出：Hello, Nashorn
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

Nashorn 提供了更好的性能和兼容性，支持 ECMAScript 5.1 标准，并且允许 Java 和 JavaScript 互操作。

9. Base64 编码和解码

Java 8 内置了 Base64 编码和解码 API，提供了对 Base64 数据的便捷处理。Base64 类提供了三种不同的编码器和解码器：

基础：适用于普通编码。
URL 和文件名安全：适用于 URL 和文件名编码。
MIME：适用于 MIME（Multipurpose Internet Mail Extensions）编码。

示例：

String originalInput = "test input";
String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());
System.out.println("Encoded: " + encodedString);

byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
String decodedString = new String(decodedBytes);
System.out.println("Decoded: " + decodedString);

10. 并行数组（Parallel Arrays）

Java 8 为数组操作引入了并行处理支持，通过 Arrays.parallelSort 等方法，可以充分利用多核处理器的性能。并行排序算法将数组分成多个子数组，并行排序，然后合并结果。

示例：

int[] array = {5, 3, 8, 1, 9, 6};
Arrays.parallelSort(array);
System.out.println(Arrays.toString(array)); // 输出排序后的数组

并行数组操作包括并行排序、并行设置值和并行前缀操作。

11. CompletableFuture

Java 8 引入了 CompletableFuture 类，增强了异步编程能力。

// 示例：CompletableFuture 的使用
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> "Hello")
                .thenApply(result -> result + " World")
                .thenAccept(result -> System.out.println(result)); // 输出：Hello World
    }
}

总结

JDK 1.8 引入了一系列强大且实用的新特性，如 Lambda 表达式、Stream API、新的日期和时间 API 等，极大地提升了 Java 语言的表达能力和开发效率。这些新特性不仅简化了代码编写，还提供了更多处理并发和数据流的工具，使得 Java 开发更加现代化和高效。通过合理使用这些新特性，可以显著提高代码的可读性、可维护性和执行性能。