Java 8 中的 10 个特性总结及详解

Java 8 是 Java 语言自从 Java 5 以来的首个重大升级版本，它带来了一系列新特性，改变了 Java 编程的方式。本文将介绍 Java 8 中的 10 个主要特性，以及它们的详解。

1. Lambda 表达式

Lambda 表达式是 Java 8 中最显著的特性之一。它以一种简明的形式表示函数式接口，使得我们可以以更简单的方式编写代码。一个 Lambda 表达式可以替代一个匿名内部类，如下所示：

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

// 使用 Lambda 表达式
Runnable runnable = () -> System.out.println("Hello World!");
new Thread(runnable).start();

2. 方法引用

方法引用是另一个 Lambda 表达式的语法糖。它使得我们可以使用已经存在的方法来代替 Lambda 表达式。例如，下面代码通过方法引用来代替 Lambda 表达式：

// 使用 Lambda 表达式
List<String> strings = Arrays.asList("hello", "world");
strings.forEach(s -> System.out.println(s));

// 使用方法引用
List<String> strings = Arrays.asList("hello", "world");
strings.forEach(System.out::println);

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

Java 8 中允许在接口中定义默认方法和静态方法。默认方法是指在接口中定义方法的实现，静态方法是指在接口中定义静态方法。下面是一个默认方法和静态方法的示例：

public interface MyInterface {
    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

4. Stream API

Stream 是 Java 8 中新增的一个流式操作 API。它允许我们以函数式的方式对集合或数组进行操作。以下是一个使用 Stream API 的示例：

// 求出一个字符串数组中所有字符串的长度之和
String[] strings = {"hello", "world"};
int sum = Arrays.stream(strings).mapToInt(String::length).sum();

5. Optional 类

Optional 类是一个容器类，可以包含一个值，也可以为空。它的主要作用是用来解决程序中的 NullPointerException 异常问题。下面是一个使用 Optional 类的示例：

public Optional<Integer> divide(int a, int b) {
    if (b == 0) {
        return Optional.empty();
    } else {
        return Optional.of(a / b);
    }
}

Optional<Integer> result = divide(10, 2);
if (result.isPresent()) {
    System.out.println(result.get());
} else {
    System.out.println("除数不能为零！");
}

6. Date/Time API

Java 8 中新增了 Date/Time API，它是对原有的 Date 和 Calendar 类的改进。它提供了很多便捷的方法来处理日期和时间。以下是一个使用 Date/Time API 的示例：

// 求出两个日期之间相差的天数
LocalDate date1 = LocalDate.of(2020, 1, 1);
LocalDate date2 = LocalDate.of(2020, 1, 10);
long days = ChronoUnit.DAYS.between(date1, date2);

7. CompletableFuture

CompletableFuture 是 Java 8 中新增的一个类，用于处理异步编程。它允许我们以更简单的方式编写异步代码。以下是一个使用 CompletableFuture 的示例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello World!";
});
completableFuture.thenAccept(System.out::println);

8. Nashorn JavaScript 引擎

Nashorn 是 Java 8 中新增的一个 JavaScript 引擎。它允许我们在 Java 程序中执行 JavaScript 代码。以下是一个使用 Nashorn 的示例：

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
engine.eval("var javaClass = Java.type('java.lang.String'); " +
            "var result = javaClass.valueOf('Hello World!');" +
            "print(result);");

9. 原生注解 @Repeatable

@Repeatable 是一个原生注解，它允许我们在同一个元素上重复使用某个注解。以下是一个使用 @Repeatable 的示例：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Marks {
    Mark[] value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Marks.class)
public @interface Mark {
    String value();
};

@Mark("A")
@Mark("B")
class MyClass {}

10. 类型注解

Java 8 中，我们可以对任意类型使用注解，包括 Class、Interface、Enum、Annotation、Method、Constructor、Field、Local Variable 等等。以下是一个使用类型注解的示例：

// 注解类
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

// 类型注解
class MyClazz<@MyAnnotation T> {
    public void doSomething(@MyAnnotation String myString) {
        @MyAnnotation List<@MyAnnotation String> myList = new ArrayList<>();
    }
}

总结

Java 8 带来了许多新特性，使得 Java 编程更加简单和高效。在本文中，我们介绍了 Java 8 中的 10 个主要特性，包括 Lambda 表达式、方法引用、接口的默认方法和静态方法、Stream API、Optional 类、Date/Time API、CompletableFuture、Nashorn JavaScript 引擎、原生注解 @Repeatable 和类型注解。这些特性有助于开发人员更高效地编写 Java 代码，并使 Java 语言更加现代化和可维护。