在Java开发中，Trade类经常包含子Trade的嵌套结构，比如订单交易中主交易下挂多个子交易，子交易还能继续嵌套更细粒度的交易数据。这种情况下需要对Trade列表做深度拆分，把不同层级的Trade提取出来分别处理，递归是最适配的实现方式。
Trade类基础结构定义
首先定义基础的Trade类，包含交易ID、交易金额、子交易列表三个核心属性，这是后续拆分处理的基础：
public class Trade {
private String tradeId;
private double amount;
private List<Trade> subTrades;
public Trade(String tradeId, double amount, List<Trade> subTrades) {
this.tradeId = tradeId;
this.amount = amount;
this.subTrades = subTrades;
}
// getter和setter方法
public String getTradeId() {
return tradeId;
}
public void setTradeId(String tradeId) {
this.tradeId = tradeId;
}
public double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public List<Trade> getSubTrades() {
return subTrades;
}
public void setSubTrades(List<Trade> subTrades) {
this.subTrades = subTrades;
}
}
深度拆分与递归处理核心逻辑
深度拆分的核心是通过递归遍历所有层级的Trade，把每一层的Trade都收集到结果列表中，同时可以根据业务需求对每层数据做处理。递归的终止条件是当前Trade没有子交易列表，或者子交易列表为空。
递归拆分方法实现
下面的方法接收原始Trade列表，返回拆分后所有层级的Trade扁平列表：
import java.util.ArrayList;
import java.util.List;
public class TradeSplitUtil {
/**
* 深度拆分Trade列表，返回所有层级的Trade集合
* @param tradeList 原始Trade列表，可能包含多层嵌套
* @return 拆分后扁平化的Trade列表
*/
public static List<Trade> deepSplitTradeList(List<Trade> tradeList) {
List<Trade> result = new ArrayList<>();
// 递归处理入口
deepSplitRecursive(tradeList, result);
return result;
}
/**
* 递归处理核心方法
* @param currentTrades 当前层级的Trade列表
* @param result 存储拆分结果的集合
*/
private static void deepSplitRecursive(List<Trade> currentTrades, List<Trade> result) {
// 空值校验，避免空指针异常
if (currentTrades == null || currentTrades.isEmpty()) {
return;
}
for (Trade trade : currentTrades) {
// 把当前层的Trade加入结果集
result.add(trade);
// 获取子交易列表
List<Trade> subTrades = trade.getSubTrades();
// 如果存在子交易，递归处理子交易
if (subTrades != null && !subTrades.isEmpty()) {
deepSplitRecursive(subTrades, result);
}
}
}
}
带层级标识的拆分实现
如果业务需要区分不同层级的Trade，可以在递归时传递层级参数，把层级信息保存到扩展的TradeVO中：
public class TradeVO {
private String tradeId;
private double amount;
private int level; // 交易所在层级，根层级为0
public TradeVO(String tradeId, double amount, int level) {
this.tradeId = tradeId;
this.amount = amount;
this.level = level;
}
// getter和setter
public String getTradeId() {
return tradeId;
}
public void setTradeId(String tradeId) {
this.tradeId = tradeId;
}
public double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
}
对应的递归处理方法调整为：
import java.util.ArrayList;
import java.util.List;
public class TradeSplitWithLevelUtil {
public static List<TradeVO> deepSplitWithLevel(List<Trade> tradeList) {
List<TradeVO> result = new ArrayList<>();
deepSplitRecursiveWithLevel(tradeList, 0, result);
return result;
}
private static void deepSplitRecursiveWithLevel(List<Trade> currentTrades, int currentLevel, List<TradeVO> result) {
if (currentTrades == null || currentTrades.isEmpty()) {
return;
}
for (Trade trade : currentTrades) {
// 封装带层级的TradeVO
TradeVO tradeVO = new TradeVO(trade.getTradeId(), trade.getAmount(), currentLevel);
result.add(tradeVO);
// 处理子交易，层级加1
List<Trade> subTrades = trade.getSubTrades();
if (subTrades != null && !subTrades.isEmpty()) {
deepSplitRecursiveWithLevel(subTrades, currentLevel + 1, result);
}
}
}
}
测试验证
构建嵌套的Trade数据测试拆分效果：
import java.util.Arrays;
import java.util.List;
public class TradeTest {
public static void main(String[] args) {
// 构建三层嵌套的Trade数据
Trade subSubTrade1 = new Trade("sub_sub_1", 100.0, null);
Trade subSubTrade2 = new Trade("sub_sub_2", 200.0, null);
Trade subTrade1 = new Trade("sub_1", 300.0, Arrays.asList(subSubTrade1, subSubTrade2));
Trade subTrade2 = new Trade("sub_2", 400.0, null);
Trade rootTrade = new Trade("root_1", 500.0, Arrays.asList(subTrade1, subTrade2));
// 测试基础拆分
List<Trade> splitResult = TradeSplitUtil.deepSplitTradeList(Arrays.asList(rootTrade));
System.out.println("基础拆分结果数量：" + splitResult.size());
for (Trade trade : splitResult) {
System.out.println("交易ID：" + trade.getTradeId() + "，金额：" + trade.getAmount());
}
// 测试带层级的拆分
List<TradeVO> splitWithLevelResult = TradeSplitWithLevelUtil.deepSplitWithLevel(Arrays.asList(rootTrade));
System.out.println("n带层级拆分结果：");
for (TradeVO tradeVO : splitWithLevelResult) {
System.out.println("交易ID：" + tradeVO.getTradeId() + "，金额：" + tradeVO.getAmount() + "，层级：" + tradeVO.getLevel());
}
}
}
注意事项
- 递归处理前必须做空值校验，避免传入空列表或者Trade的子交易列表为空时抛出空指针异常。
- 如果Trade嵌套层级过深，可能会出现栈溢出问题，这种情况下可以考虑把递归改为栈或队列的迭代实现。
- 如果拆分后需要对不同层级的Trade做不同业务处理，可以在递归时根据层级参数添加对应的处理逻辑，不需要拆分完成后再做二次遍历。
- 如果原始Trade列表数据量较大，拆分结果列表可以考虑使用初始容量设置，减少扩容带来的性能损耗。