Java 用子对象列表更新主对象列表

我有

交易

对象，它有

子交易

（交易列表），我需要更新

子交易

DealDTO

对象具有

子代码列表

，因此我需要为每个

子代码找到
Deal
对象，并将
subDeals
更新为
Deal

以下是
Deal
课程：

public class Deal {
    String code;
    BigDecimal price;
    List<Deal> subDeals;
    public Deal(String code, BigDecimal price) {
        super();
        this.code = code;
        this.price = price;
        this.subDeals = new ArrayList<>();
    }
    // geteer setter
    public void addSubDeal(Deal subDeal) {
        subDeals.add(subDeal);
    }
}

以下是我正在尝试的方法，但它不起作用：

List<Deal> masterDeals =
            Arrays.asList(
                new Deal("ABC",new BigDecimal(5)),
                new Deal("DEF",new BigDecimal(10)),
                new Deal("GHI",new BigDecimal(15))
                );

    List<DealDTO> dealDTOs =
            Arrays.asList(
                new DealDTO("ABC", Arrays.asList("JKL")),
                new DealDTO("DEF", Arrays.asList("JKL", "ABC")),
                new DealDTO("GHI", Arrays.asList("MNO"))
                );

DealDTO dealDTO = null;

for(Deal masterDeal : masterDeals) {
    // get DealDTO which matches with masterDeal's code
    dealDTO = dealDTOs.stream()
            .filter(dto -> dto.getMasterCode().equals(masterDeal.getCode()))
            .findFirst()
            .get();
    // if subCodes are present then traverse through it and get the Deal object from masterDeals list and update the masterDeal
    if(dealDTO.getSubCodes() != null && !dealDTO.getSubCodes().isEmpty()) {
        dealDTO.getSubCodes().stream().forEach( code -> {
            for(Deal deal : masterDeals) {
                if(deal.getCode().equals(code)) {
                    masterDeal.addSubDeal(deal);
                }
            }
        });
    }
    // subDeals has been added so persist masterDeal here
}
masterDeals.forEach(System.out::println);  // throws java.lang.StackOverflowError

列出主交易=
Arrays.asList(
新政（“ABC”，新BigDecimal（5）），
新政（“DEF”，新的BigDecimal（10）），
新政（“GHI”，新的大十进制（15））
);
上市交易=
Arrays.asList(
新DealTo（“ABC”，Arrays.asList（“JKL”），
新的DealDTO（“DEF”，Arrays.asList（“JKL”，“ABC”），
新DealTo（“GHI”，Arrays.asList（“MNO”））
);
DealDTO DealDTO=null；
for（交易主交易：主交易）{
//获取与masterDeal代码匹配的Deald
dealDTO=dealDTOs.stream（）
.filter（dto->dto.getMasterCode（）.equals（masterDeal.getCode（）））
.findFirst（）
.get（）；
//如果存在子代码，则遍历它，从masterDeals列表中获取交易对象并更新masterDeal
if（dealDTO.getsubcode（）！=null&&！dealDTO.getsubcode（）.isEmpty（））{
dealDTO.GetSubcode（）.stream（）.forEach（代码->{
for（交易：masterDeals）{
if（deal.getCode（）.equals（code））{
主交易。添加子交易（交易）；
}
}
});
}
//已添加子交易，因此请在此处坚持masterDeal
}
masterDeals.forEach（System.out:：println）；//抛出java.lang.StackOverflower错误

列表非常庞大，因此我想确保我采用了正确的方法来更新
子交易
因为您提到了列表非常庞大，所以您可以做一些事情来提高性能

使用地图来保存交易，而不是列表。给定一个代码，您应该能够快速检索交易
如果可能，让交易也只保存子交易的
code
。提供getter
List getSubDeals
，在需要时创建列表并返回
看起来您的交易和子交易之间存在循环依赖关系。这就是堆栈溢出的原因。您认为实际数据中存在这种依赖关系吗？在这种情况下，您需要有某种机制来跟踪交易是否被访问。@KDM是的，
deal
有
subDeals
，
subDeals
实际上是测试数据中
deal
的列表，“Abc”作为子交易具有“Def”，而“Abc”则具有子交易。这就是我所说的数据的循环依赖性（不是结构）。您的真实数据也是这样吗？@KDM感谢您指出这一点。数据量很大，所以我不确定它是否具有循环依赖性。你能为这种逻辑推荐一种好的方法吗？自引用结构并不意味着数据可能具有循环依赖性。取决于数据是否可以循环依赖项您需要创建逻辑。接受作为答案，因为它帮助我确定了问题，谢谢
List<Deal> masterDeals =
            Arrays.asList(
                new Deal("ABC",new BigDecimal(5)),
                new Deal("DEF",new BigDecimal(10)),
                new Deal("GHI",new BigDecimal(15))
                );

    List<DealDTO> dealDTOs =
            Arrays.asList(
                new DealDTO("ABC", Arrays.asList("JKL")),
                new DealDTO("DEF", Arrays.asList("JKL", "ABC")),
                new DealDTO("GHI", Arrays.asList("MNO"))
                );

DealDTO dealDTO = null;

for(Deal masterDeal : masterDeals) {
    // get DealDTO which matches with masterDeal's code
    dealDTO = dealDTOs.stream()
            .filter(dto -> dto.getMasterCode().equals(masterDeal.getCode()))
            .findFirst()
            .get();
    // if subCodes are present then traverse through it and get the Deal object from masterDeals list and update the masterDeal
    if(dealDTO.getSubCodes() != null && !dealDTO.getSubCodes().isEmpty()) {
        dealDTO.getSubCodes().stream().forEach( code -> {
            for(Deal deal : masterDeals) {
                if(deal.getCode().equals(code)) {
                    masterDeal.addSubDeal(deal);
                }
            }
        });
    }
    // subDeals has been added so persist masterDeal here
}
masterDeals.forEach(System.out::println);  // throws java.lang.StackOverflowError