Lambda Streams Collectors.summingDouble动态函数参数

我有以下代码，如果我硬编码pojo方法Employee:：GetBaseAlary

Map<Date, Map<String, Double>> $r = list
                                .stream()
                                .filter((p) -> (StringUtils.equalsIgnoreCase(p.getActiveInd(), "Y")
                                                && CoreUtils.greaterThanOrEquals(p.getCreateDate(), paramDate) && (null == p.getEmpDate())))
                                .collect(Collectors.groupingBy(dateFn,
                                         Collectors.groupingBy(empCodeFn,
                                         Collectors.summingDouble(Employee::getBaseSalary))));

---

我认为你不应该在

collect

部分做那一步；相反，它应该是一些

map

one的一部分。但由于这是

收集器的一部分

，我会选择

收集器。映射

，如下所示：

Map<Date, Map<String, Double>> $r = list
       .stream()
       .filter((p) -> (StringUtils.equalsIgnoreCase(p.getActiveInd(), "Y")
                                            && CoreUtils.greaterThanOrEquals(p.getCreateDate(), paramDate) && (null == p.getEmpDate())))
       .collect(Collectors.groupingBy(dateFn,
             Collectors.groupingBy(empCodeFn,
             Collectors.mapping(o-> {
                   if(Type.BaseSalary.equals(calculationType)) 
                        return o.getBaseSalary();
                   else return o.getTotalSalary();
             }, Collectors.summingDouble(x -> x)
   ))));

Map$r=list
.stream（）
.filter（（p）->（StringUtils.equalsIgnoreCase（p.getActiveInd（），“Y”）
&&CoreUtils.greaterThanOrEquals（p.getCreateDate（），paramDate）&&（null==p.getEmpDate（））
.collect（收集器）。分组方式（日期fn，
收藏家。分组依据（empCodeFn，
收集器。映射（o->{
if（Type.BaseSalary.equals（calculationType））
返回o.getBaseAlary（）；
否则返回o.getTotalSalary（）；
}，收集器。求和双精度（x->x）
))));

我认为您不应该在

收集部分执行该步骤；相反，它应该是一些
map
one的一部分。但由于这是
收集器的一部分
，我会选择
收集器。映射
，如下所示：

Map<Date, Map<String, Double>> $r = list
       .stream()
       .filter((p) -> (StringUtils.equalsIgnoreCase(p.getActiveInd(), "Y")
                                            && CoreUtils.greaterThanOrEquals(p.getCreateDate(), paramDate) && (null == p.getEmpDate())))
       .collect(Collectors.groupingBy(dateFn,
             Collectors.groupingBy(empCodeFn,
             Collectors.mapping(o-> {
                   if(Type.BaseSalary.equals(calculationType)) 
                        return o.getBaseSalary();
                   else return o.getTotalSalary();
             }, Collectors.summingDouble(x -> x)
   ))));

Map$r=list
.stream（）
.filter（（p）->（StringUtils.equalsIgnoreCase（p.getActiveInd（），“Y”）
&&CoreUtils.greaterThanOrEquals（p.getCreateDate（），paramDate）&&（null==p.getEmpDate（））
.collect（收集器）。分组方式（日期fn，
收藏家。分组依据（empCodeFn，
收集器。映射（o->{
if（Type.BaseSalary.equals（calculationType））
返回o.getBaseAlary（）；
否则返回o.getTotalSalary（）；
}，收集器。求和双精度（x->x）
))));
但它会给出编译错误：为什么不阅读并发布错误？DimTask:：getSalary在我看来不像是一个以雇员为参数的函数。我已经更新了代码和错误详细信息。当编译器告诉您必须使用
来处理双倍函数时，而不是使用
函数
，只需将
函数
替换为
来处理双倍函数
。你到底为什么要改变其他与编译器错误无关的东西呢？但是它会给你带来编译错误：你为什么不阅读并发布错误呢？DimTask:：getSalary在我看来不像是一个以雇员为参数的函数。我已经更新了代码和错误详细信息。当编译器告诉您必须使用
来处理双倍函数时，而不是使用
函数
，只需将
函数
替换为
来处理双倍函数
。究竟为什么要更改与编译器错误无关的其他内容？在每次函数求值中都不需要重新求值
Type.BaseSalary.equals（calculationType）
。您可以使用
Type.BaseSalary.equals（calculationType）？o->o.getBaseAlary（）：o->o.getTotalSalary（）
。或者使用方法引用
Type.BaseSalary.equals（calculationType）？员工：：getBaseSalary:Employee：：getTotalSalary
。这相当于OP最初的方法，唯一的障碍是当编译器告诉您需要一个
ToDoubleFunction
时，使用
ToDoubleFunction
，而不是
Function
。无需在每次函数求值中重新求值
Type.BaseSalary.equals（calculationType）
。您可以使用
Type.BaseSalary.equals（calculationType）？o->o.getBaseAlary（）：o->o.getTotalSalary（）
。或者使用方法引用
Type.BaseSalary.equals（calculationType）？员工：：getBaseSalary:Employee：：getTotalSalary
。这相当于OP最初的方法，唯一的障碍是当编译器告诉您需要一个
ToDoubleFunction
时，使用
ToDoubleFunction
而不是
Function
…
        Collectors.summingDouble((o)->{if(Type.BaseSalary.equals(calculationType)) 
      return o.getBaseSalary();
 else return o.getTotalSalary();
}))));

Map<Date, Map<String, Double>> $r = list
       .stream()
       .filter((p) -> (StringUtils.equalsIgnoreCase(p.getActiveInd(), "Y")
                                            && CoreUtils.greaterThanOrEquals(p.getCreateDate(), paramDate) && (null == p.getEmpDate())))
       .collect(Collectors.groupingBy(dateFn,
             Collectors.groupingBy(empCodeFn,
             Collectors.mapping(o-> {
                   if(Type.BaseSalary.equals(calculationType)) 
                        return o.getBaseSalary();
                   else return o.getTotalSalary();
             }, Collectors.summingDouble(x -> x)
   ))));