1. Lambda表达式

Lambda表达式是Java 8最引人注目的特性之一。它允许我们以更简洁的方式编写代码，并将函数作为一等公民进行传递。

// Lambda表达式示例：求两个数的和
BinaryOperator<Integer> sum = (a, b) -> a + b;
int result = sum.apply(2, 3);  // 结果为5

// Lambda表达式示例：打印字符串
Consumer<String> printString = s -> System.out.println(s);
printString.accept("Hello, world!");  // 输出：Hello, world!

Lambda表达式使用 (参数列表) -> 表达式或代码块 的语法。在第一个示例中，我们定义了一个求和的Lambda表达式，它接受两个整数参数，并返回它们的和。在第二个示例中，我们定义了一个打印字符串的Lambda表达式，它接受一个字符串参数并在控制台打印它。

2. 函数式接口

函数式接口是只包含一个抽象方法的接口。Java 8引入了java.util.function包，其中包含了许多内置的函数式接口，例如Predicate、Function和Supplier等。

// Predicate示例：判断字符串是否为空
Predicate<String> isEmpty = s -> s.isEmpty();
boolean empty = isEmpty.test("");  // 结果为true

// Function示例：将字符串转换为大写
Function<String, String> toUpperCase = s -> s.toUpperCase();
String upperCaseString = toUpperCase.apply("hello");  // 结果为"HELLO"

// Supplier示例：生成随机数
Supplier<Integer> random = () -> (int) (Math.random() * 100);
int randomNumber = random.get();  // 生成一个0到99之间的随机数

Predicate接口用于判断给定的参数是否满足某个条件，Function接口用于将给定的参数转换为另一种类型，Supplier接口用于提供一个结果。通过Lambda表达式，我们可以以简洁的方式实现这些接口的方法。

3. 方法引用

方法引用是一种更简洁地调用方法的方式。它允许我们通过方法的名称来引用已有的方法，而不是编写Lambda表达式。

// 静态方法引用示例
Function<Integer, String> convertToString = Integer::toString;
String str = convertToString.apply(123);  // 结果为"123"

// 实例方法引用示例
List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(System.out::println);  // 打印列表中的每个元素

// 构造函数引用示例
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> newList = listSupplier.get();  // 创建一个新的ArrayList对象

静态方法引用使用类名::静态方法名的语法，实例方法引用使用实例::实例方法名的语法，构造函数引用使用类名::new的语法。方法引用使得代码更加简洁易读，并且可以重复使用现有的方法。

4. Stream API

Stream API提供了一种流式操作集合的方式，可以更方便地对集合进行过滤、映射、排序等操作。

// 创建Stream示例
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Stream<Integer> stream = numbers.stream();

// 过滤操作示例
stream.filter(n -> n % 2 == 0)  // 过滤出偶数
    .forEach(System.out::println);  // 打印偶数

// 映射操作示例
List<String> words = Arrays.asList("Java", "is", "awesome");
words.stream()
    .map(String::toUpperCase)  // 将字符串转换为大写
    .forEach(System.out::println);  // 打印大写字符串

// 排序操作示例
List<Integer> sortedNumbers = numbers.stream()
    .sorted()  // 升序排序
    .collect(Collectors.toList());  // 将结果收集到列表中

首先，我们通过调用集合的stream()方法来创建一个流。然后，我们可以对流进行中间操作，如过滤、映射和排序等。最后，我们可以进行终端操作，如打印、收集或计数等。

5. 默认方法

默认方法是接口中可以包含实现的方法。在Java 8之前，接口只能声明方法，但不能提供实现。默认方法允许我们向接口中添加新的方法，而不会破坏现有的实现类。

interface Greeting {
    void sayHello();

    default void sayGoodbye() {
        System.out.println("Goodbye!");
    }
}

class GreetingImpl implements Greeting {
    public void sayHello() {
        System.out.println("Hello!");
    }
}

Greeting greeting = new GreetingImpl();
greeting.sayHello();  // 输出：Hello!
greeting.sayGoodbye();  // 输出：Goodbye!

我们定义了一个Greeting接口，其中包含一个抽象方法sayHello()和一个默认方法sayGoodbye()。然后我们实现了该接口的一个实现类GreetingImpl。通过创建GreetingImpl对象，我们可以调用sayHello()方法和默认的sayGoodbye()方法。

6. Optional类

Optional类是Java 8引入的一个用于处理可能为空的值的容器类。它提供了一种优雅的方式来处理可能的空指针异常。

Optional<String> optionalString = Optional.of("Hello");
boolean isPresent = optionalString.isPresent();  // 判断Optional是否包含值
String value = optionalString.get();  // 获取Optional中的值

Optional<String> optionalEmpty = Optional.empty();
String defaultValue = optionalEmpty.orElse("Default Value");  // 如果Optional为空，则返回默认值

我们展示了Optional类的一些常用方法。通过调用Optional.of()方法，我们可以将一个非空的值包装在Optional对象中。然后，我们可以使用isPresent()方法来判断Optional是否包含值，并使用get()方法获取Optional中的值。如果Optional为空，我们可以使用orElse()方法设置一个默认值。

7. 新的日期/时间API

Java 8引入了全新的日期/时间API（java.time包），以替代旧的java.util.Date和java.util.Calendar类。新的API提供了更加简洁、易用和线程安全的日期和时间操作方式。

// 获取当前日期和时间
LocalDateTime now = LocalDateTime.now();

// 进行日期的加减操作
LocalDateTime future = now.plusDays(7);
LocalDateTime past = now.minusHours(3);

// 日期的格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = now.format(formatter);

我们展示了新的日期/时间API的一些常用操作。通过LocalDateTime.now()方法，我们可以获取当前的日期和时间。然后，我们可以使用plusDays()和minusHours()等方法进行日期的加减操作。最后，我们可以使用DateTimeFormatter类定义日期的格式，并使用format进行格式化。

8. 并行流

Java 8引入了并行流（Parallel Streams），它是Stream API的一个扩展，可以在多个线程上并行执行流操作。通过并行流，我们可以更好地利用多核处理器的优势，加快对大量数据的处理速度。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 串行流操作
int sumSerial = numbers.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(n -> n)
    .sum();

// 并行流操作
int sumParallel = numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .mapToInt(n -> n)
    .sum();

我们展示了串行流和并行流的比较。通过调用stream()方法，我们可以创建一个串行流进行操作，而通过调用parallelStream()方法，我们可以创建一个并行流进行操作。在并行流操作中，流中的元素会被分成多个小块，每个小块都在不同的线程上并行处理，最后再将结果合并。