Java 迭代ArrayList并以特定格式添加到另一个ArrayList

添加到ArrayList的有效方法

我有一个arrayList，如下所示：

Name    id  zone    cases
Test    12  Above   20
Test1   13  In      30
Test1   13  Above   12
Test1   13  Below   10
Test1   14  Above   2
Test1   14  In      8
Test1   14  Below   6

我必须迭代这个arrayList并创建这种类型的结果列表

Name    id  zone    cases
Test    12  Above   20
Test    12  In      0
Test    12  Below   0
Total               20
Test1   13  Above   30
Test1   13  In      12
Test1   13  Below   10
Total               52
Test1   14  Above   2
Test1   14  In      8
Test1   14  Below   6
Total               16

虽然名称“Test”没有“In”和“Below”，但我必须将这些值添加到包含0个案例的列表中。它应该是动态迭代，但“上面”、“里面”和“下面”是静态的。

---

此外，该名称将有多个id，如test1的id为13和14。每个部分都应该在列表中添加一个名为“总计”的部分。有什么建议吗？

你的课程应该是这样的。这就是你要找的。如果你愿意的话，只需要放一些独特的id逻辑。如果液位刚好高于/低于/低于，则执行更多的逻辑流程。在开始时初始化它们并更新它们的数据

公共枚举级别{

Above("Above"),
In("In"),
Below("Below");

private String level;

Level(String level) {
    this.level =level;
}

public String getLevel() {
    return level;
}

}

公开课考试{

private String name;

private Integer id;

private Level level;

private Integer count;

public Test(String name, Integer id, Level level, Integer count) {
    this.name = name;
    this.id = id;
    this.level = level;
    this.count = count;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Integer getId() {
    return id;
}

public void setId(Integer id) {
    this.id = id;
}

public Level getLevel() {
    return level;
}

public void setLevel(Level level) {
    this.level = level;
}

public Integer getCount() {
    return count;
}

public void setCount(Integer count) {
    this.count = count;
}

@Override
public String toString() {
    return "Test [name=" + name + ", id=" + id + ", level=" + level
            + ", count=" + count + "]";
}

}

导入java.util.HashSet； 导入java.util.Set

公共类聚合器{

private Set<Test> testList;

private int totalCount;

public Aggregator() {
    if(testList==null)
        testList = new HashSet<Test>();
    totalCount=0;
}

public void addTest(Test test) {
    testList.add(test);
    totalCount = totalCount + test.getCount();
}

public Set<Test> getTestList() {
    return testList;
}



@Override
public String toString() {
    return "Aggregator [testList=" + testList + ", totalCount="
            + totalCount + "]";
}

public int getTotalCount() {
    return totalCount;
}

public void setTotalCount(int totalCount) {
    this.totalCount = totalCount;
}

私有集测试列表；
私人整数总数；
公共聚合器（）{
if（testList==null）
testList=newhashset（）；
totalCount=0；
}
公共测试（测试）{
testList.add（test）；
totalCount=totalCount+test.getCount（）；
}
公共集getTestList（）{
返回测试列表；
}
@凌驾
公共字符串toString（）{
返回“聚合器[testList=“+testList+”，totalCount=”
+总数+“]”；
}
public int getTotalCount（）{
返回totalCount；
}
公共无效setTotalCount（整数totalCount）{
this.totalCount=totalCount；
}

}

导入java.util.ArrayList； 导入java.util.List

公共阶级结构{

private List<Aggregator> data;

public Structure() {
    if(data==null) {
        data = new ArrayList<Aggregator>();
    }
}

public List<Aggregator> getData() {
    return data;
}

私有列表数据；
公共结构（）{
如果（数据==null）{
数据=新的ArrayList（）；
}
}
公共列表getData（）{
返回数据；
}

}

导入java.util.List

公共类聚合测试{

public static void main(String[] args) {
    Structure structure = new Structure();
    List<Aggregator> finalData = structure.getData();
    Test test = new Test("Test", 1, Level.Above, 10);
    Test test1 = new Test("Test", 1, Level.In, 10);
    Test test2 = new Test("Test1", 2, Level.Above, 10);
    Test test3 = new Test("Test1", 2, Level.In, 10);

    Aggregator aggregator = new Aggregator();
    aggregator.addTest(test);
    aggregator.addTest(test1);

    Aggregator aggregator2 = new Aggregator();
    aggregator2.addTest(test2);
    aggregator2.addTest(test3);

    finalData.add(aggregator);
    finalData.add(aggregator2);
    for (Aggregator entry : finalData) {
        System.out.println(entry);
    }

}

publicstaticvoidmain（字符串[]args）{
结构=新结构（）；
List finalData=structure.getData（）；
测试=新测试（“测试”，1级，10级以上）；
测试1=新测试（“测试”，1，等级In，10）；
测试2=新测试（“测试1”，2，级别以上，10）；
测试test3=新测试（“测试1”，2，等级In，10）；
聚合器聚合器=新聚合器（）；
聚合器。addTest（测试）；
aggregator.addTest（test1）；
Aggregator Aggregator 2=新的聚合器（）；
聚合器2.addTest（test2）；
聚合器2.addTest（test3）；
最终数据添加（聚合器）；
最终数据添加（聚合器2）；
对于（聚合器条目：finalData）{
系统输出打印项次（输入）；
}
}

}

输出：

聚合器[testList=[Test[name=Test，id=1，level=Upper，count=10]，Test[name=Test，id=1，level=In，count=10]，totalCount=20]

---

聚合器[testList=[Test[name=Test1，id=2，level=Upper，count=10]，Test[name=Test1，id=2，level=In，count=10]]，totalCount=20]

因此，对于每个id，添加元素以确保最后出现“上”-“下”-“下”-“总计”？如果第一个列表中的n元素的形式为

Test3 15，则第二个列表中会发生什么？什么是
动态迭代
？你有没有尝试过任何方法来解决这个问题，你做了多少呢？我的意思是名字是动态的，id可以是任何值。没有必要让value Name='Test'或id='12'或13'.@tucuxi我开始了，我对如何继续感到困惑，因此请求建议。从实际的类开始，这些类的实例可以真正存储在
ArrayList
中，而不是那些表中。