Java 8 引入了一些非常重要的新特性，使得 Java 编程变得更加简洁、灵活和功能强大。以下是 Java 8 的几个主要新特性：

1. Lambda 表达式

Lambda 表达式是 Java 8 最具标志性的特性之一，它使得 Java 程序可以像函数式编程语言一样处理代码。Lambda 表达式允许你将代码块作为参数传递给方法，或者将其存储为变量。

示例：

import java.util.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");

        // 使用 Lambda 表达式遍历集合
        list.forEach(item -> System.out.println(item));
    }
}

上述代码使用 Lambda 表达式来遍历一个集合，并打印每个元素。

2. 函数式接口

函数式接口是只有一个抽象方法的接口。Lambda 表达式和方法引用的目标类型是函数式接口。

示例：

@FunctionalInterface
public interface MyFunctionalInterface {
    void apply(int x, int y);
}

使用 Lambda 表达式：

MyFunctionalInterface myFunc = (x, y) -> System.out.println(x + y);
myFunc.apply(5, 10);  // 输出: 15

3. Stream API

Stream API 是 Java 8 引入的一个新库，使得集合操作（如过滤、排序、映射等）变得更加简洁和函数式。Stream API 支持并行处理，极大地提升了性能。

示例：

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用 Stream API 进行筛选和映射
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .map(n -> n * 2)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers);  // 输出: [4, 8, 12, 16, 20]
    }
}

4. 默认方法（Default Methods）

默认方法使得接口可以有方法的实现，而不需要在每个实现类中进行实现。这样可以在不破坏现有接口的情况下，向接口添加新功能。

示例：

public interface MyInterface {
    // 默认方法
    default void defaultMethod() {
        System.out.println("这是一个默认方法");
    }

    void abstractMethod();
}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("这是抽象方法的实现");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod();    // 输出: 这是抽象方法的实现
        obj.defaultMethod();     // 输出: 这是一个默认方法
    }
}

5. 方法引用 (Method References)

方法引用是 Lambda 表达式的一种简写方式，它允许直接引用类或实例的方法。

示例：

import java.util.*;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");

        // 使用方法引用来替代 Lambda 表达式
        list.forEach(System.out::println);
    }
}

在这个例子中，System.out::println 就是方法引用，相当于 item -> System.out.println(item)。

6. Optional 类

Optional 是 Java 8 引入的一个容器类，它用于表示可能为空的值。它是避免空指针异常（NullPointerException）的一个重要工具。

示例：

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> nonEmpty = Optional.of("Hello");
        Optional<String> empty = Optional.empty();

        // 判断是否有值
        System.out.println(nonEmpty.isPresent());  // 输出: true
        System.out.println(empty.isPresent());     // 输出: false

        // 获取值
        System.out.println(nonEmpty.get());  // 输出: Hello
    }
}

7. 新的日期时间 API（java.time）

Java 8 引入了全新的日期和时间 API，位于 java.time 包下。它解决了 java.util.Date 和 java.util.Calendar 的一些不足，具有更高的可读性和更好的时间操作功能。

示例：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;

public class DateTimeExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();

        System.out.println("当前日期: " + date);
        System.out.println("当前时间: " + time);
        System.out.println("当前日期时间: " + dateTime);
    }
}

8. Nashorn JavaScript 引擎

Java 8 引入了 Nashorn JavaScript 引擎，它允许在 Java 中直接运行 JavaScript 代码，比原来的 Rhino 引擎性能更好。

示例：

import javax.script.*;

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

        // 执行 JavaScript 代码
        engine.eval("print('Hello, Nashorn!')");
    }
}

9. 重复注解

Java 8 允许在同一代码元素上使用多个相同的注解，这对于使用框架时特别有用。

示例：

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

public class MyClass {
    @MyAnnotation("Hello")
    @MyAnnotation("World")
    public void myMethod() {}
}

10. Parallel Streams

Java 8 的 Stream API 支持并行操作，使得你可以轻松实现并行处理，从而提高性能。

示例：

import java.util.*;
import java.util.stream.*;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用并行流来加速处理
        int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();
        System.out.println("总和: " + sum);
    }
}

总结

Java 8 引入了大量新特性，使得 Java 编程更加灵活和强大，尤其是在函数式编程和并行处理方面。你可以通过 Lambda 表达式、Stream API、默认方法等大大简化代码，同时提升性能。

更多详细内容请关注其他相关文章。