Java 多对象属性流的累积和

我有一个按月-年字符串属性排序的对象列表。 我的对象类定义如下

Public class Obj{
    String year;
    Long membercount;
    Long nonmembercount;
    Double memberpayment;
    Double nonmemberpayment;
}

new Obj("9-2015",100,20,10,5)
new Obj("10-2015",220,40,20,55)
new Obj("11-2015",300,60,30,45)
new Obj("12-2015",330,30,50,6)
new Obj("1-2016",100,10,10,4)

我想对

membercount

，

nonmembercount

，

memberpayment

，

nonmemberpayment

因此，我的新对象列表如下所示

new Obj("9-2015",100,20,10,5)
new Obj("10-2015",320,60,30,60)
new Obj("11-2015",620,120,60,105)
new Obj("12-2015",950,150,110,111)
new Obj("1-2016",1050,160,120,115)

我尝试了

收集器。summingDouble

但它提供的是所有总和，而不是累积

---

非常感谢您的指点。

根据我对您问题的理解，这是我能够想到的

我使用

map（o->o.membercount）

和

collector（Collectors.summingDouble（n->n））

对每个字段进行计算。看一看

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class DoubleSummation {

    public static void main(String[] args) {
        List<Obj> list = new ArrayList<>();
        list.add(new Obj("9-2015",100,20,10,5));
        list.add(new Obj("10-2015",220,40,20,55));
        list.add(new Obj("11-2015",300,60,30,45));
        list.add(new Obj("12-2015",330,30,50,6));
        list.add(new Obj("1-2016",100,10,10,4));

        Double sumMemberCount = list.stream().mapToDouble(o->o.membercount).sum();
        Double sumNonmembercount = list.stream().mapToDouble(o->o.nonmembercount).sum();
        Double sumMemberpayment = list.stream().mapToDouble(o->o.memberpayment).sum();
        Double sumNonmemberpayment = list.stream().mapToDouble(o->o.nonmemberpayment).sum();

        System.out.println(sumMemberCount);
        System.out.println(sumNonmembercount);
        System.out.println(sumMemberpayment);
        System.out.println(sumNonmemberpayment);
    }
}

class Obj{

    String year;
    long membercount;
    long nonmembercount;
    double memberpayment;
    double nonmemberpayment;

    public Obj(String year, long membercount, long nonmembercount, double memberpayment, double nonmemberpayment) {
        this.year = year;
        this.membercount = membercount;
        this.nonmembercount = nonmembercount;
        this.memberpayment = memberpayment;
        this.nonmemberpayment = nonmemberpayment;
    }

}

import java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
公共类双重求和{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
增加（新的Obj（“9-2015”，100,20,10,5））；
增加（新的Obj（“10-2015”，220,40,20,55））；
增加（新的Obj（“11-2015”，300,60,30,45））；
增加（新的Obj（“12-2015”，330,30,50,6））；
增加（新的Obj（“1-2016”，100,10,10,4））；
Double-sumMemberCount=list.stream（）.mapToDouble（o->o.membercount.sum（）；
Double-sumNonmembercount=list.stream（）.mapToDouble（o->o.nonmembercount.sum（）；
Double sumMemberpayment=list.stream（）.mapToDouble（o->o.memberpayment.sum（）；
Double-sumNonmemberpayment=list.stream（）.mapToDouble（o->o.nonmemberpayment.sum（）；
System.out.println（总和成员计数）；
System.out.println（sumNonmembercount）；
系统输出打印项次（总付款）；
System.out.println（非会员支付）；
}
}
Obj类{
弦年；
长期会员人数；
长非成员计数；
双会员支付；
双重非会员支付；
公共Obj（字符串年份、长成员计数、长非成员计数、双成员支付、双非成员支付）{
今年=年；
this.membercount=membercount；
this.nonmembercount=非成员计数；
this.memberpayment=memberpayment；
this.nonmemberpayment=非成员支付；
}
}

---

希望这有帮助

我的解决方案：

List<Obj> objects = ...;
int cumulSum[] = {0};

objects.stream().map(obj -> {
    cumulSum[0] += obj.membercount;
    return new Obj(obj.year, cumulSum[0], ...);
});

列出对象=。。。；
int cumulSum[]={0}；
objects.stream（）.map（obj->{
积云[0]+=obj.membercount；
返回新Obj（Obj.年，积云[0]，…）；
});

流API中没有对累积操作的直接支持，尽管可以通过自定义

收集器实现这种操作。但值得注意的是，已经有了对阵列上此类操作的直接支持，这对于您的情况可能已经足够了：

将
Obj
的草图扩展到

public class Obj {
    String year;
    Long membercount;
    Long nonmembercount;
    Double memberpayment;
    Double nonmemberpayment;

    public Obj(String year, long membercount, long nonmembercount,
            double memberpayment, double nonmemberpayment) {
        this.year = year;
        this.membercount = membercount;
        this.nonmembercount = nonmembercount;
        this.memberpayment = memberpayment;
        this.nonmemberpayment = nonmemberpayment;
    }

    @Override
    public String toString() {
        return "Obj("+year+", "+membercount+", "+nonmembercount
            +", "+memberpayment+", "+nonmemberpayment+')';
    }
}

解决方案可以如下所示：

// test data
List<Obj> list=Arrays.asList(
    new Obj("9-2015", 100, 20, 10, 5),
    new Obj("10-2015", 220, 40, 20, 55),
    new Obj("11-2015", 300, 60, 30, 45),
    new Obj("12-2015", 330, 30, 50, 6),
    new Obj("1-2016", 100, 10, 10, 4));

// creating an array as need for the operation, it will contain the
// result afterwards, whereas the source list is not modified
Obj[] array = list.toArray(new Obj[0]);

// the actual operation
Arrays.parallelPrefix(array, (a,b) -> new Obj(b.year,
    a.membercount + b.membercount,
    a.nonmembercount + b.nonmembercount,
    a.memberpayment + b.memberpayment,
    a.nonmemberpayment + b.nonmemberpayment
));

// just print the result
Arrays.asList(array).forEach(System.out::println);

虽然此操作不太可能受益于对这少量元素的并行处理，但遗憾的是，此操作没有顺序版本。所以你可以考虑使用一个普通的循环解代替…


为了完整起见，这里是一个基于流收集器的累积操作解决方案。与
array.parallelPrefix
类似，update函数必须没有副作用且具有关联性，这是函数返回具有汇总属性的新对象的情况

public static <T> Collector<T,?,List<T>> cumulative(BinaryOperator<T> update) {
    return Collector.of(ArrayList::new,
        (l,o) -> {
            if(!l.isEmpty()) o=update.apply(l.get(l.size()-1), o);
            l.add(o);
        },
        (l,m) -> {
            if(l.isEmpty()) return m;
            if(!m.isEmpty()) {
                T a = l.get(l.size()-1);
                for(T b: m) l.add(update.apply(a, b));
            }
            return l;
        });
}

公共静态收集器累积（二进制运算符更新）{
返回收集器.of（ArrayList:：new，
（l，o）->{
如果（！l.isEmpty（））o=update.apply（l.get（l.size（）-1），o；
l、 添加（o）；
},
（l，m）->{
如果（l.isEmpty（））返回m；
如果（！m.isEmpty（））{
T a=l.get（l.size（）-1）；
对于（tb:m）l.add（update.apply（a，b））；
}
返回l；
});
}

将其与上述设置一起使用：

List<Obj> result = list.stream().collect(cumulative((a,b) -> new Obj(b.year,
    a.membercount + b.membercount,
    a.nonmembercount + b.nonmembercount,
    a.memberpayment + b.memberpayment,
    a.nonmemberpayment + b.nonmemberpayment
)));

List result=List.stream（）.collect（累计）（a，b）->新Obj（b.year，
a、 membercount+b.membercount，
a、 非成员计数+b.非成员计数，
a、 memberpayment+b.memberpayment，
a、 非会员付款+b.非会员付款
)));
您不能流式传输原始JSON。这代表某种阶级吗？这个类看起来像什么？@shmosel是的，它代表POJO类。为了更清楚，我将JSON显示为JSON，JSON会混淆而不是澄清。请发布实际的类定义。这是一个编码请求。投票关闭。仍然没有类定义。看到一个
映射到
double
，然后是
收集器，真的很奇怪。summingDouble
，现在需要一个标识函数。为什么不直接在收集器中使用映射函数，即
list.stream（）.collect（collector.summingDouble（o->o.field））
？此外，还值得考虑使用
list.stream（）.mapToDouble（o->o.field）.sum（）
，并将结果变量的类型更改为
double
。但是你的解决方案计算的是总和而不是累计总和…@Holger是的，你是对的，我得到的是总和而不是累计。感谢你在这方面的帮助我想要累计总和，而不是所有属性的总和。非常感谢你的指点