本教程详细探讨了如何利用 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 优化策略，它们分别侧重于原地修改和函数式转换。
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);
}
}优点：
- 代码简洁，比传统 for 循环更具可读性。
- 直接在原列表上操作，无需创建新列表，节省内存（如果这是期望的行为）。
- removeIf 是 List 接口自带的优化方法，效率较高。
缺点：
- forEach 内部的副作用（修改 ipc 对象）与函数式编程的“无副作用”原则略有偏离。
- 如果需要返回一个全新的列表而不是修改原有列表，则不适用。
2. 策略二：使用 peek、filter 和 collect 进行函数式转换
这种策略更符合 Stream API 的函数式编程范式，它通过一系列操作将流中的元素转换为新的元素或新的集合
