Java 对列表中的所有属性值求和

我有一个类，有几个整数，类似于：

public class Test {
    private Integer a;
    private Integer b;
    private Integer c;
    private Integer d;
    private Integer e;
    private Integer f;
    private Integer g;
}

List<Test> tests = testRepository.findAllTest();

Test test = new Test();
for (Test testList: tests) {
    test.setA(test.getA + testList.getA);
    test.setB(test.getB + testList.getB);
    test.setC(test.getC + testList.getC);
    test.setD(test.getD + testList.getD);
    test.setE(test.getE + testList.getE);
    test.setF(test.getF + testList.getF);
    test.setG(test.getG + testList.getG);
}
 return test;

所以，我得到了这个类的一个列表，其中有很多寄存器，我必须对这个列表的所有属性分别求和。然后我做了类似的事情：

public class Test {
    private Integer a;
    private Integer b;
    private Integer c;
    private Integer d;
    private Integer e;
    private Integer f;
    private Integer g;
}

List<Test> tests = testRepository.findAllTest();

Test test = new Test();
for (Test testList: tests) {
    test.setA(test.getA + testList.getA);
    test.setB(test.getB + testList.getB);
    test.setC(test.getC + testList.getC);
    test.setD(test.getD + testList.getD);
    test.setE(test.getE + testList.getE);
    test.setF(test.getF + testList.getF);
    test.setG(test.getG + testList.getG);
}
 return test;

List tests=testRepository.findAllTest（）；
测试=新测试（）；
用于（测试列表：测试）{
setA（test.getA+testList.getA）；
test.setB（test.getB+testList.getB）；
test.setC（test.getC+testList.getC）；
test.setD（test.getD+testList.getD）；
test.setE（test.getE+testList.getE）；
test.setF（test.getF+testList.getF）；
test.setG（test.getG+testList.getG）；
}
回归试验；

---

这个实现工作得很好，但我现在想知道，如果有更简单的方法，清理代码并使其变得简单，我会将其分解为几个子问题：将一个测试对象添加到另一个，并总结列表

对于第一个问题，您可以向测试类添加一个方法，该方法添加两个测试对象并返回一个包含和的新测试对象

public class Test {
    ...

    public Test add(Test testToAdd){
        Test result = new Test();
        result.setA(a + testToAdd.getA());
        ...
        result.setG(g + testToAdd.getG());
        return result;
    }
}

然后你可以在求和循环中调用它：

List<Test> tests = testRepository.findAllTest();
Test testTotal = new Test();
for (Test test: tests) {
    testTotal = testTotal.add(test);
}

List tests=testRepository.findAllTest（）；
Test testTotal=新测试（）；
用于（测试：测试）{
testTotal=testTotal.add（测试）；
}

---

另一个好处是可以更直接地了解循环在做什么。

您可以修改测试类以包含add方法：

public class Test {
    private int a;
    private int b;
    private int c;
    //...

    public void add(Test o) {
        this.a += o.getA();
        this.b += o.getB();
        this.c += o.getC();
        //...
    }
    // setters and getters...
}

然后求和函数可以如下所示：

public Test summation(Collection<Test> testCollection) {
    Test sum = new Test();
    for(Test test : testCollection) {
        sum.add(test);
    }
    return sum;
}

公共测试总和（集合testCollection）{
测试和=新测试（）；
for（测试：testCollection）{
相加（测试）；
}
回报金额；
}

使用

流对现有答案添加一种类似的方法。reduce

：

如果您还没有无参数构造函数，请将其添加到测试类中：

private Test() {
    this(0,0,0,0,0,0,0);
}

向测试类添加addAttributes方法

public Test addAttributes(Test other){
    this.a += other.a; 
    this.b += other.b; 
    this.c += other.c; 
    this.d += other.d;
    //.... 
    return this;
}

然后，您可以通过执行以下操作来减少列表：

Test result = tests.stream().reduce(new Test(), (t1,t2) -> t1.addAttributes(t2));

在

Test

类中编写一个

add（Test other）

方法：

public void add(Test other) {
   this.a += other.getA();
   this.b += other.getB();
   // ...
   this.g += other.getG();
}

然后，要使用它：

Test test = new Test();
List<Test> allTests = testRepository.findAllTest();
allTests.forEach(individualTest -> individualTest.add(test));
return test;

Test Test=新测试（）；
List allTests=testRepository.findAllTest（）；
allTests.forEach（individualTest->individualTest.add（test））；
回归试验；

我怀疑它是否正常，因为您正在每行调用

setA（）。你可以将它包装在一个add方法中，比如
void addAttributes（Test other）
使用一个包含7个
int
元素的数组，然后将它们添加到一个循环中。Joakim Danielson我编辑过，感谢你的观察你也可以让add方法修改测试对象而不是返回一个新的，然后在循环中你可以调用testTotal.add（测试）