Java 8新特性实战解析：案例驱动，轻松掌握 Stream API、Lambda 表达式等实用技巧

Java 8作为Java语言的一个重要版本，引入了许多新的特性和改进，其中Stream API和Lambda表达式是两个最为显著的变化。这些新特性不仅简化了代码的编写，还提高了代码的可读性和性能。本文将通过案例驱动的方式，详细解析Java 8的新特性，帮助读者轻松掌握Stream API、Lambda表达式等实用技巧。

Stream API：简化集合操作

Stream API是Java 8引入的一个全新抽象，用于处理集合中的元素。它允许你以声明式的方式处理集合，从而简化了集合操作。

案例一：过滤和映射

假设我们有一个学生类（Student），包含姓名和成绩两个属性。现在我们需要找出所有成绩大于90分的学生，并打印他们的姓名。

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

public class Main {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 85),
            new Student("Bob", 92),
            new Student("Charlie", 78),
            new Student("David", 95)
        );

        List<String> names = students.stream()
            .filter(s -> s.getScore() > 90)
            .map(Student::getName)
            .collect(Collectors.toList());

        names.forEach(System.out::println);
    }
}

class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
}

在这个例子中，我们使用了Stream API的filter和map方法来过滤和映射学生对象。filter方法用于过滤出成绩大于90分的学生，map方法用于将学生对象转换为姓名字符串。

案例二：排序和分组

假设我们有一个员工类（Employee），包含姓名、部门和年龄三个属性。现在我们需要按照年龄对员工进行排序，并按照部门进行分组。

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

public class Main {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 28),
            new Employee("Bob", "Tech", 32),
            new Employee("Charlie", "HR", 25),
            new Employee("David", "Tech", 35)
        );

        List<Employee> sortedEmployees = employees.stream()
            .sorted((e1, e2) -> e1.getAge() - e2.getAge())
            .collect(Collectors.toList());

        Map<String, List<Employee>> groupedEmployees = employees.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));

        sortedEmployees.forEach(System.out::println);
        groupedEmployees.forEach((department, employeesList) -> {
            System.out.println(department);
            employeesList.forEach(System.out::println);
        });
    }
}

class Employee {
    private String name;
    private String department;
    private int age;

    public Employee(String name, String department, int age) {
        this.name = name;
        this.department = department;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getDepartment() {
        return department;
    }

    public int getAge() {
        return age;
    }
}

在这个例子中，我们使用了Stream API的sorted和groupingBy方法来排序和分组员工对象。sorted方法用于按照年龄对员工进行排序，groupingBy方法用于按照部门对员工进行分组。

Lambda表达式：简化代码编写

Lambda表达式是Java 8引入的一个新特性，允许你以更简洁的方式编写代码。它主要用于实现函数式编程。

案例一：匿名内部类与Lambda表达式

假设我们有一个比较器接口（Comparator），用于比较两个字符串。

import java.util.Arrays;
import java.util.Comparator;

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

        // 使用匿名内部类
        strings.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });

        // 使用Lambda表达式
        strings.sort((s1, s2) -> s1.compareTo(s2));

        strings.forEach(System.out::println);
    }
}

在这个例子中，我们使用了匿名内部类和Lambda表达式来实现比较器接口。Lambda表达式简化了代码的编写，提高了代码的可读性。

案例二：函数式接口与Lambda表达式

假设我们有一个函数式接口（Function），用于将一个对象转换为另一个对象。

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

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

        // 使用Lambda表达式
        List<String> upperCaseStrings = strings.stream()
            .map(s -> s.toUpperCase())
            .collect(Collectors.toList());

        upperCaseStrings.forEach(System.out::println);
    }
}

在这个例子中，我们使用了Lambda表达式来实现函数式接口。Lambda表达式简化了代码的编写，提高了代码的可读性和性能。

总结

Java 8的新特性为Java语言带来了许多便利。通过Stream API和Lambda表达式，我们可以更简洁、更高效地编写代码。本文通过案例驱动的方式，详细解析了Java 8的新特性，帮助读者轻松掌握Stream API、Lambda表达式等实用技巧。希望读者能够将这些新特性应用到实际项目中，提高代码质量和开发效率。