Java 8 Stream API：优化列表处理与条件更新的实践指南-java教程-PHP中文网

Java 8 Stream API：优化列表处理与条件更新的实践指南

心靈之曲

发布： 2025-11-22 22:04:02

原创

463人浏览过

Java 8 Stream API：优化列表处理与条件更新的实践指南

本教程详细探讨了如何利用 java 8 stream api 优化传统循环中对列表元素的条件更新和过滤操作。文章通过分析一个具体案例，展示了使用 `foreach` 结合 `removeif` 进行原地修改，以及使用 `peek`、`filter` 和 `collect` 实现函数式转换并生成新列表的两种主要策略，旨在提升代码的简洁性和可读性。

在现代 Java 应用开发中，Java 8 引入的 Stream API 已经成为处理集合数据不可或缺的工具。它提供了一种声明式、函数式的方法来处理数据，使得代码更加简洁、易读且易于并行化。本文将通过一个具体的业务场景，深入探讨如何将传统的基于循环的列表处理逻辑，优雅地转换为使用 Stream API 的现代 Java 风格。

原始问题分析

我们首先来看一个常见的业务场景：一个 Item 对象包含一个 ItemPriceCode 列表。我们需要遍历这个列表，根据每个 ItemPriceCode 的特定属性和 Item 的制造商ID，从数据库中查询相关信息，并据此更新 ItemPriceCode 中的一个字段。最后，还需要从列表中移除那些被标记为“已删除”的 ItemPriceCode。

原始代码示例如下：

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

// 假设的常量和实体类
final class Constants {
    public static final String NOT_DELETED = "NOT_DELETED";
    public static final String DELETED = "DELETED";
}

class ManufacturerPriceCodes {
    private String name;
    public ManufacturerPriceCodes(String name) { this.name = name; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

class ItemPriceCode {
    private String priceCode;
    private String manufacturerPriceCode; // 待更新字段
    private String recordDeleted;

    public ItemPriceCode(String priceCode, String recordDeleted) {
        this.priceCode = priceCode;
        this.recordDeleted = recordDeleted;
    }
    // 复制构造函数，用于函数式编程场景
    public ItemPriceCode(ItemPriceCode other) {
        this.priceCode = other.priceCode;
        this.manufacturerPriceCode = other.manufacturerPriceCode;
        this.recordDeleted = other.recordDeleted;
    }
    // Getters and Setters
    public String getPriceCode() { return priceCode; }
    public String getManufacturerPriceCode() { return manufacturerPriceCode; }
    public void setManufacturerPriceCode(String manufacturerPriceCode) { this.manufacturerPriceCode = manufacturerPriceCode; }
    public String getRecordDeleted() { return recordDeleted; }
    public void setRecordDeleted(String recordDeleted) { this.recordDeleted = recordDeleted; }

    @Override
    public String toString() {
        return "ItemPriceCode{priceCode='" + priceCode + "', manufacturerPriceCode='" + manufacturerPriceCode + "', recordDeleted='" + recordDeleted + "'}";
    }
}

class Item {
    private String manufacturerID;
    private List<ItemPriceCode> itemPriceCodes;

    public Item(String manufacturerID, List<ItemPriceCode> itemPriceCodes) {
        this.manufacturerID = manufacturerID;
        this.itemPriceCodes = itemPriceCodes;
    }
    // Getters and Setters
    public String getManufacturerID() { return manufacturerID; }
    public List<ItemPriceCode> getItemPriceCodes() { return itemPriceCodes; }
    public void setItemPriceCodes(List<ItemPriceCode> itemPriceCodes) { this.itemPriceCodes = itemPriceCodes; }

    @Override
    public String toString() {
        return "Item{manufacturerID='" + manufacturerID + "', itemPriceCodes=" + itemPriceCodes + "}";
    }
}

// 模拟的 JPA Repository
interface ManufacturerPriceCodesRepository {
    Optional<ManufacturerPriceCodes> findByManufacturerIDAndPriceCodeAndRecordDeleted(String manufacturerID, String priceCode, String recordDeleted);
}

class MockManufacturerPriceCodesRepository implements ManufacturerPriceCodesRepository {
    @Override
    public Optional<ManufacturerPriceCodes> findByManufacturerIDAndPriceCodeAndRecordDeleted(String manufacturerID, String priceCode, String recordDeleted) {
        if (Constants.NOT_DELETED.equals(recordDeleted) && "M_ID_A".equals(manufacturerID)) {
            if ("PC1".equals(priceCode)) return Optional.of(new ManufacturerPriceCodes("MPC_Name_1"));
            if ("PC2".equals(priceCode)) return Optional.of(new ManufacturerPriceCodes("MPC_Name_2"));
            if ("PC3".equals(priceCode)) return Optional.of(new ManufacturerPriceCodes("MPC_Name_3"));
        }
        return Optional.empty();
    }
}

public class ItemProcessor {

    private ManufacturerPriceCodesRepository manufacturerPriceCodesRepository = new MockManufacturerPriceCodesRepository(); // 注入或实例化

    private Item getItemManufacturerPriceCodes(Item item) {
        List<ItemPriceCode> itemPriceCodes = item.getItemPriceCodes();

        // 步骤1: 遍历并条件更新
        for (ItemPriceCode ipc : itemPriceCodes) {
            Optional<ManufacturerPriceCodes> mpc = manufacturerPriceCodesRepository.findByManufacturerIDAndPriceCodeAndRecordDeleted(
                item.getManufacturerID(), ipc.getPriceCode(), Constants.NOT_DELETED);

            if (mpc.isPresent()) {
                ipc.setManufacturerPriceCode(mpc.get().getName());
            }
        }

        // 步骤2: 移除已删除的项
        item.getItemPriceCodes()
            .removeIf(ipc -> Constants.DELETED.equals(ipc.getRecordDeleted()));

        return item;
    }

    // ... main 方法或测试方法
}

登录后复制

这段代码实现了两个主要功能：

立即学习“Java免费学习笔记（深入）”；

条件更新: 遍历 itemPriceCodes 列表，根据外部查询结果更新每个 ItemPriceCode 对象的 manufacturerPriceCode 字段。
原地过滤: 使用 removeIf 方法从列表中移除符合特定条件的元素（recordDeleted 为 DELETED）。

Java 8 Stream API 优化方案

我们将探讨两种主要的 Java 8 Stream API 优化策略，它们分别侧重于原地修改和函数式转换。

ListenLeap

AI辅助通过播客学英语

101

查看详情

1. 策略一：使用 forEach 和 removeIf 进行原地修改

这种策略是对原始代码最直接的 Java 8 化，它保留了对现有列表元素进行原地修改的特点。List.forEach() 和 List.removeIf() 都是 Java 8 引入的默认方法，非常适合这种场景。

实现方式：

条件更新: 使用 forEach 遍历 ItemPriceCode 列表，并在 lambda 表达式内部执行数据库查询和条件更新逻辑。Optional.ifPresent() 方法在这里非常有用，它能简洁地处理查询结果存在时的操作。
原地过滤: removeIf 方法本身就是 Java 8 的特性，可以直接使用，它会在遍历列表时移除满足谓词条件的元素。

public class ItemProcessorOptimized1 {

    private ManufacturerPriceCodesRepository manufacturerPriceCodesRepository = new MockManufacturerPriceCodesRepository();

    public Item getItemManufacturerPriceCodes(Item item) {
        List<ItemPriceCode> itemPriceCodes = item.getItemPriceCodes();

        // 步骤1: 使用 forEach 进行条件更新
        itemPriceCodes.forEach(ipc ->
            manufacturerPriceCodesRepository.findByManufacturerIDAndPriceCodeAndRecordDeleted(
                item.getManufacturerID(), ipc.getPriceCode(), Constants.NOT_DELETED)
                .ifPresent(mpc -> ipc.setManufacturerPriceCode(mpc.get().getName()))
        );

        // 步骤2: 使用 removeIf 移除已删除的项
        itemPriceCodes.removeIf(ipc -> Constants.DELETED.equals(ipc.getRecordDeleted()));

        return item;
    }

    public static void main(String[] args) {
        ItemProcessorOptimized1 processor = new ItemProcessorOptimized1();

        List<ItemPriceCode> initialCodes = new ArrayList<>();
        initialCodes.add(new ItemPriceCode("PC1", Constants.NOT_DELETED));
        initialCodes.add(new ItemPriceCode("PC2", Constants.NOT_DELETED));
        initialCodes.add(new ItemPriceCode("PC_DELETED", Constants.DELETED));
        initialCodes.add(new ItemPriceCode("PC3", Constants.NOT_DELETED));
        initialCodes.add(new ItemPriceCode("PC_NON_EXISTENT", Constants.NOT_DELETED));

        Item item = new Item("M_ID_A", initialCodes);
        System.out.println("原始 Item: " + item);

        Item processedItem = processor.getItemManufacturerPriceCodes(item);
        System.out.println("处理后 Item (策略一): " + processedItem);
    }
}

登录后复制

优点：