关于Java中**optional，stream，lambda**

关于Java中optional，stream，lambda

Lambda表达式高效使用

java 复制代码

// 1. 结合Comparator进行排序
List<Person> persons = Arrays.asList(
    new Person("John", 25),
    new Person("Alice", 22),
    new Person("Bob", 30)
);

// 按年龄排序
persons.sort((p1, p2) -> p1.getAge() - p2.getAge());

// 2. 事件处理
button.addActionListener(e -> System.out.println("Button clicked"));

// 3. 自定义函数式接口使用
@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

// 加法lambda
MathOperation add = (a, b) -> a + b;
// 乘法lambda
MathOperation multiply = (a, b) -> a * b;

System.out.println(add.operation(5, 3));      // 输出: 8
System.out.println(multiply.operation(5, 3));  // 输出: 15

Stream API高效使用

java 复制代码

List<Person> persons = Arrays.asList(
    new Person("John", 25, "US", 3000),
    new Person("Alice", 22, "UK", 4000),
    new Person("Bob", 30, "US", 5000)
);

// 1. 复杂数据处理链
Map<String, Double> avgSalaryByCountry = persons.stream()
    .filter(p -> p.getSalary() > 2000)              // 过滤
    .collect(Collectors.groupingBy(                  // 分组
        Person::getCountry,                         
        Collectors.averagingDouble(Person::getSalary)
    ));

// 2. 并行处理大数据集
long count = persons.parallelStream()
    .filter(p -> p.getAge() > 25)
    .count();

// 3. 数值统计
DoubleSummaryStatistics salaryStats = persons.stream()
    .mapToDouble(Person::getSalary)
    .summaryStatistics();
System.out.println("Average salary: " + salaryStats.getAverage());
System.out.println("Max salary: " + salaryStats.getMax());

// 4. 数据转换和收集
List<String> names = persons.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

// 5. 查找和匹配
boolean anyMatch = persons.stream()
    .anyMatch(p -> p.getAge() > 30);

Optional高效使用

java 复制代码

public class OptionalDemo {
    // 1. 优雅处理可能为空的对象
    public String getCarInsuranceName(Optional<Person> person) {
        return person.flatMap(Person::getCar)
                    .flatMap(Car::getInsurance)
                    .map(Insurance::getName)
                    .orElse("Unknown");
    }

    // 2. 链式调用避免空指针
    public Optional<String> getUppercaseName(Person person) {
        return Optional.ofNullable(person)
                      .map(Person::getName)
                      .map(String::toUpperCase);
    }

    // 3. 条件处理
    public void printNameIfPresent(Optional<String> name) {
        name.ifPresent(System.out::println);
        name.ifPresentOrElse(
            System.out::println,    // 值存在时执行
            () -> System.out.println("Name not found")  // 值不存在时执行
        );
    }

    // 4. 默认值处理
    public String getNameWithDefault(Optional<String> name) {
        return name.orElseGet(() -> "Default Name");  // 延迟加载默认值
    }

    // 5. 组合多个Optional
    public Optional<String> getCombinedName(Optional<String> firstName, Optional<String> lastName) {
        return firstName.flatMap(f -> 
            lastName.map(l -> f + " " + l)
        );
    }

    // 6. 过滤值
    public Optional<Person> getAdultPerson(Optional<Person> person) {
        return person.filter(p -> p.getAge() > 18);
    }
}

// 实体类示例
class Person {
    private String name;
    private int age;
    private Optional<Car> car;  // 使用Optional作为字段类型

    public Optional<Car> getCar() {
        return car;
    }
}

class Car {
    private Optional<Insurance> insurance;

    public Optional<Insurance> getInsurance() {
        return insurance;
    }
}

class Insurance {
    private String name;

    public String getName() {
        return name;
    }
}

一些最佳实践建议：

Lambda表达式:

保持简短，复杂逻辑应该提取到方法中
使用方法引用代替简单的lambda表达式
注意避免副作用

Stream API:

对大数据集使用并行流(parallelStream)
使用合适的终端操作(terminal operation)
避免在stream操作中修改外部状态
善用collect操作进行数据收集

Optional:

不要将Optional用作类的字段类型（除非特殊需求）
优先使用Optional的map和flatMap进行链式调用
使用orElseGet代替orElse处理默认值
不要使用Optional.get()，除非确定有值