Java 包含不同对象的两个列表的公共部分

我有两个列表，一个包含

ProductDto

，另一个包含

consumerdProductdto

@Builder
@Getter
@ToString
public class ProductDto {
    private final String id;
    private final String productName;
    private final Double calories;
    private final Double protein;
    private final Double fat;
    private final Double carbohydrates;
    private final Double weight;
}

@Getter
@Builder
@ToString
public class ConsumedProductDto {
    private final String username;
    private final LocalDate date;
    private final String productID;
    private final Double weight;
}

现在，我想得到这两个列表的公共部分，如果

ProductDto.id==consummedproductdto.productID

我编写该函数就是为了做到这一点：

private List<ProductDto> matchingProducts(List<ProductDto> products, List<ConsumedProductDto> consumedProducts) {
        return products.stream().filter(product ->
                consumedProducts.stream()
                        .allMatch(consumedProduct ->
                              product.getId().equals(consumedProduct.getProductID())))
                .collect(Collectors.toList());
    }

私有列表匹配产品（列表产品、列表消费产品）{
return products.stream（）.filter（产品->
consumedProducts.stream（）
.allMatch（消费品->
product.getId（）.equals（consumedProduct.getProductID（）））
.collect（Collectors.toList（））；
}

它可以工作，直到我有两个（或更多）使用相同的

productID

的

ConsumedProductDto

。然后，当我想要两个（或更多）产品时，我只得到一个产品

你知道哪里出了问题吗？

---

另外，我知道我可以

@Override equals（）

并用

contains（）

检查那些公共部分，但是像这样混合两个不同的类是好主意吗

我从对评论的回复中了解到，您实际上是在根据过滤条件为多个

ConsumedProductTo

s的输出中查找多个

ProductDto

条目，以匹配这些产品

因此，您感兴趣的是遍历

ConsumedProductTo

s，并找到要在最终输出中收集的

productDto

s和

map

的任何匹配项。这可能类似于以下方法：

private List<ProductDto> matchingProducts(List<ProductDto> products, List<ConsumedProductDto> consumedProducts) {
    return consumedProducts.stream()
            .map(consumedProductDto -> products.stream()
                    .filter(productDto -> productDto.getId().equals(consumedProductDto.getProductID()))
                    .findAny().orElse(null))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
}

私有列表匹配产品（列表产品、列表消费产品）{
返回consumedProducts.stream（）
.map（consumedProductDto->products.stream（）
.filter（productDto->productDto.getId（）.equals（consumedProductDto.getProductID（）））
.findAny（）.orElse（null））
.filter（对象：：非空）
.collect（Collectors.toList（））；
}

我从对评论的回复中了解到，您实际上是在输出中查找多个

ProductDto

条目，以根据过滤条件匹配多个

消费品dto

s

因此，您感兴趣的是遍历

ConsumedProductTo

s，并找到要在最终输出中收集的

productDto

s和

map

的任何匹配项。这可能类似于以下方法：

private List<ProductDto> matchingProducts(List<ProductDto> products, List<ConsumedProductDto> consumedProducts) {
    return consumedProducts.stream()
            .map(consumedProductDto -> products.stream()
                    .filter(productDto -> productDto.getId().equals(consumedProductDto.getProductID()))
                    .findAny().orElse(null))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
}

私有列表匹配产品（列表产品、列表消费产品）{
返回consumedProducts.stream（）
.map（consumedProductDto->products.stream（）
.filter（productDto->productDto.getId（）.equals（consumedProductDto.getProductID（）））
.findAny（）.orElse（null））
.filter（对象：：非空）
.collect（Collectors.toList（））；
}

它可以工作，直到我有两个（或更多）具有相同productID的ConsumedProductTo。然后，当我想要两个（或更多）产品时，我只得到一个产品。。。你的意思是如果有1个

ProductDto

和

productID:xyz

的

ProductDto

和2个

consumerdProductdto

的

ProductDto

在输出结果中会出现两次

ProductDto

？或者其他什么？是的，这正是我的意思。它是有效的，直到我有两个（或更多）消费品使用相同的产品ID。然后，当我想要两个（或更多）产品时，我只得到一个产品。。。你的意思是如果有1个

ProductDto

和

productID:xyz

的

ProductDto

和2个

consumerdProductdto

的

ProductDto

在输出结果中会出现两次

ProductDto

？或者别的什么？是的，这正是我的意思。