Java 8作为Java语言的一个重要版本，引入了许多新的特性和改进，这些特性极大地提升了开发效率和性能。以下，我将通过十大实用案例，带你轻松掌握Java 8的新特性。

1. Lambda表达式与Stream API

案例：使用Lambda表达式和Stream API来处理集合数据。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaStreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 使用Lambda表达式过滤出以字母"B"开头的名字
        List<String> startsWithB = names.stream()
                .filter(name -> name.startsWith("B"))
                .collect(Collectors.toList());

        System.out.println(startsWithB);
    }
}

2. 方法引用

案例：使用方法引用简化代码。

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 使用方法引用来排序
        names.sort(String::compareTo);

        System.out.println(names);
    }
}

3. 默认方法

案例：在接口中添加默认方法。

public interface Animal {
    default void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 输出: Woof!
    }
}

4. 新的日期和时间API

案例：使用新的日期和时间API处理日期。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println(date); // 输出当前日期

        String formattedDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        System.out.println(formattedDate); // 输出格式化的日期
    }
}

5. 新的集合操作

案例：使用新的集合操作简化代码。

import java.util.List;
import java.util.stream.Collectors;

public class CollectorsExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 使用新的集合操作来转换所有名字为大写
        List<String> upperCaseNames = names.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println(upperCaseNames);
    }
}

6. CompletableFuture

案例：使用CompletableFuture处理异步操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, World!";
        });

        future.thenAccept(System.out::println);
    }
}

7. 新的文件API

案例：使用新的文件API读取文件。

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;

public class FilesExample {
    public static void main(String[] args) {
        try {
            List<String> lines = Files.readAllLines(Paths.get("example.txt"));
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8. 新的Optional类

案例：使用Optional类避免空指针异常。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String name = "Alice";

        Optional<String> optionalName = Optional.ofNullable(name);
        optionalName.ifPresent(System.out::println); // 输出: Alice
    }
}

9. 新的并发API

案例：使用新的并发API简化并发编程。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class ConcurrencyExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running in a separate thread.");
        });

        future.get(); // 等待异步任务完成
    }
}

10. 新的集合类

案例：使用新的集合类Map的merge方法。

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.merge("Alice", 1, Integer::sum);
        map.merge("Bob", 1, Integer::sum);

        System.out.println(map); // 输出: {Alice=2, Bob=1}
    }
}

通过以上案例，我们可以看到Java 8的新特性如何帮助我们提高开发效率与性能。希望这些案例能够帮助你更好地理解和应用Java 8的新特性。