使用流Java8或SQL对类进行分组，以最好的为准
数据是这样的使用流Java8或SQL对类进行分组，以最好的为准,java,sql,java-stream,Java,Sql,Java Stream,数据是这样的 head child assigned total [ Mas Mas1 2 5 , Mas Mas2 0 5 , Usr usr1 4 4 , Usr usr2 1 3 , Inv Inv1 3 5 , Inv Inv2 2 3 , Inv Inv3 2 3 , Inv Inv4 1 3 ] [
head child assigned total
[ Mas Mas1 2 5
, Mas Mas2 0 5
, Usr usr1 4 4
, Usr usr2 1 3
, Inv Inv1 3 5
, Inv Inv2 2 3
, Inv Inv3 2 3
, Inv Inv4 1 3
]
[ Mas 2 10 Mas1 2 5
, Mas 2 10 Mas2 0 5
, Usr 5 7 usr1 4 4
, Usr 5 7 usr2 1 3
, Inv 8 14 Inv1 3 5
, Inv 8 14 Inv2 2 3
, Inv 8 14 Inv3 2 3
, Inv 8 14 Inv4 1 3
]
select head,
SUM(childAssigned) over (partition by am.acl_group) as assignedHead,
sum(childTotal) over (partition by am.acl_group) as totalHead,
child,
childAssigned,
childTotal
class AclList{
String head;
Integer assignedHead;
Integer totalHead;
String child;
Integer assignedChild;
Integer totalChild;
}
head child assigned total
[ Mas Mas1 2 5
, Mas Mas2 0 5
, Usr usr1 4 4
, Usr usr2 1 3
, Inv Inv1 3 5
, Inv Inv2 2 3
, Inv Inv3 2 3
, Inv Inv4 1 3
]
[ Mas 2 10 Mas1 2 5
, Mas 2 10 Mas2 0 5
, Usr 5 7 usr1 4 4
, Usr 5 7 usr2 1 3
, Inv 8 14 Inv1 3 5
, Inv 8 14 Inv2 2 3
, Inv 8 14 Inv3 2 3
, Inv 8 14 Inv4 1 3
]
收集器在这里可以帮助您
设置：
//原始数据列表
类AclList{
线头；
整数分配头；
整数总水头；
串子；
整数赋值子代；
整数totalChild；
}
//基于Json的响应对象中的子类型
类子类型{
字符串类型；
整数赋值；
整数合计；
公共子类型（字符串类型、整数分配、整数总计）{
this.type=type；
this.assigned=assigned；
这个.总计=总计；
}
}
//基于Json的响应对象
班级反应{
字符串类型；
整数赋值；
整数合计；
列表子类型；
公共响应（字符串类型、整数分配、整数总计、列表子类型）{
this.type=type；
this.assigned=assigned；
这个.总计=总计；
this.subType=子类型；
}
}
步骤1:根据类aclist
中的head
字段对数据进行分组。此步骤返回一个不同head
值的Map
作为键，一个aclist
对象列表作为值，按键分组
Map groupedByHead=数据
.stream（）
.collect（collector.groupingBy（acl->acl.head））；
第2步：只需操纵映射即可创建所需的响应结构
List response=groupedByHead.entrySet（）
.stream（）
.filter（e->e.getValue（）.size（）>0）
.map（e->{
列表ACL=e.getValue（）；
AclList first=acls.get（0）；
列出子项=ACL
.stream（）
.map（acl->新子类型（acl.child、acl.assignedChild、acl.totalChild））
.collect（Collectors.toList（））；
返回新响应（first.head、first.assignedHead、first.totalHead、children）；
})
.collect（Collectors.toList（））；
注意：我不确定您的限制，但最好在数据库查询中执行分组操作，而不是在代码中执行分组操作。流收集器
可以在这里帮助您
设置：
//原始数据列表
类AclList{
线头；
整数分配头；
整数总水头；
串子；
整数赋值子代；
整数totalChild；
}
//基于Json的响应对象中的子类型
类子类型{
字符串类型；
整数赋值；
整数合计；
公共子类型（字符串类型、整数分配、整数总计）{
this.type=type；
this.assigned=assigned；
这个.总计=总计；
}
}
//基于Json的响应对象
班级反应{
字符串类型；
整数赋值；
整数合计；
列表子类型；
公共响应（字符串类型、整数分配、整数总计、列表子类型）{
this.type=type；
this.assigned=assigned；
这个.总计=总计；
this.subType=子类型；
}
}
步骤1:根据类aclist
中的head
字段对数据进行分组。此步骤返回一个不同head
值的Map
作为键，一个aclist
对象列表作为值，按键分组
Map groupedByHead=数据
.stream（）
.collect（collector.groupingBy（acl->acl.head））；
第2步：只需操纵映射即可创建所需的响应结构
List response=groupedByHead.entrySet（）
.stream（）
.filter（e->e.getValue（）.size（）>0）
.map（e->{
列表ACL=e.getValue（）；
AclList first=acls.get（0）；
列出子项=ACL
.stream（）
.map（acl->新子类型（acl.child、acl.assignedChild、acl.totalChild））
.collect（Collectors.toList（））；
返回新响应（first.head、first.assignedHead、first.totalHead、children）；
})
.collect（Collectors.toList（））；
注意：我不确定您的约束，但最好在数据库查询中执行分组操作，而不是在代码中执行。是的，可以使用JAVA stream（）完成。
package com.bbc.enums;
import lombok.*;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.*;
import java.util.stream.Collectors;
public class StackOverFlow {
public static void main(String[] args) {
List<AclList> aclLists = Arrays.asList(
new AclList("Mas", 2, 10, "Mas1", 2, 5),
new AclList("Mas", 2, 10, "Mas2", 0, 5),
new AclList("USR", 5, 7, "USR1", 4, 4),
new AclList("USR", 5, 7, "USR2", 1, 3),
new AclList("Inv", 8, 14, "Inv1", 3, 5),
new AclList("Inv", 8, 14, "Inv2", 2, 3),
new AclList("Inv", 8, 14, "Inv3", 2, 3),
new AclList("Inv", 8, 14, "Inv4", 1, 3)
);
Map<String, Map<Integer, Map<Integer, List<AclList>>>> collect = aclLists.stream()
.collect(Collectors.groupingBy(AclList::getHead, Collectors.groupingBy(AclList::getAssignedHead,
Collectors.groupingBy(AclList::getTotalHead))));
List<HashMap<String, Object>> resList = new ArrayList<>();
collect.forEach((k1, v1) -> {
HashMap<String, Object> res = new HashMap<>();
res.put("type", k1);
v1.forEach((k2, v2) -> {
res.put("assigned", k2);
v2.forEach((k3, v3) -> {
res.put("total", k3);
List<HashMap<String, Object>> list = new ArrayList<>();
v3.forEach(aclList -> {
HashMap<String, Object> map1 = new HashMap<>();
map1.put("type", aclList.getChild());
map1.put("assigned", aclList.getAssignedChild());
map1.put("total", aclList.getTotalChild());
list.add(map1);
});
res.put("subType", list);
});
});
resList.add(res);
});
System.out.println(resList);
// if you want json response then
System.out.println(listmap_to_json_string(resList));
}
public static String listmap_to_json_string(List<HashMap<String, Object>> list) {
JSONArray json_arr = new JSONArray();
for (Map<String, Object> map : list) {
JSONObject json_obj = new JSONObject();
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
try {
json_obj.put(key, value);
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
json_arr.put(json_obj);
}
return json_arr.toString();
}
}
@AllArgsConstructor
@Getter
@Setter
@ToString
@NoArgsConstructor
class AclList {
String head;
Integer assignedHead;
Integer totalHead;
String child;
Integer assignedChild;
Integer totalChild;
}
package com.bbc.enums；
进口龙目。*；
导入org.json.JSONArray；
导入org.json.JSONException；
导入org.json.JSONObject；
导入java.util.*；
导入java.util.stream.collector；
公共类堆栈溢出{
公共静态void main（字符串[]args）{
List aclLists=Arrays.asList(
新AclList（“Mas”，2,10，“Mas1”，2,5），
新AclList（“Mas”，2,10，“Mas2”，0,5），
新的AclList（“USR”，5,7，“USR1”，4,4），
新的AclList（“USR”，5,7，“USR2”，1,3），
新的AclList（“Inv”，8,14，“Inv1”，3,5），
新的AclList（“Inv”，8,14，“Inv2”，2,3），
新的AclList（“Inv”，8,14，“Inv3”，2,3），
新AclList（“Inv”，8，14，“Inv4”，1，3）
);
Map collect=aclsists.stream（）
.collect（Collectors.groupingBy）（AclList:：getHead，Collectors.groupingBy）（AclList:：getAssignedHead，
上校