我们在Java中是否有任何聚合器函数来执行以下聚合？
Person {
String name;
String subject;
String department;
Long mark1;
Long mark2;
Long mark3;
}
列表包含以下数据。
Name |Subject |Department |Mark1 |Mark2 |Mark3 --------|-----------|-----------|-------|-------|----- Clark |English |DEP1 |7 |8 |6 Michel |English |DEP1 |6 |4 |7 Dave |Maths |DEP2 |3 |5 |6 Mario |Maths |DEP1 |9 |7 |8
聚合标准是主题＆amp; DEP的保护。结果对象需要
Subject |Department |Mark1 |Mark2 |Mark3 ----------- |-----------|-------|-------|----- English |DEP1 |13 |12 |13 Maths |DEP2 |3 |5 |6 Maths |DEP1 |9 |7 |8
可以通过手动迭代列表并创建聚合列表来实现此聚合。示例如下。
private static List<Person> getGrouped(List<Person> origList) {
Map<String, Person> grpMap = new HashMap<String, Person>();
for (Person person : origList) {
String key = person.getDepartment() + person.getSubject();
if (grpMap.containsKey(key)) {
Person grpdPerson = grpMap.get(key);
grpdPerson.setMark1(grpdPerson.getMark1() + person.getMark1());
grpdPerson.setMark2(grpdPerson.getMark2() + person.getMark2());
grpdPerson.setMark3(grpdPerson.getMark3() + person.getMark3());
} else {
grpMap.put(key, person);
}
}
return new ArrayList<Person>(grpMap.values());
}
但是我们可以利用Java 8的任何聚合功能或特性吗？
答案 0 :(得分：4)
您可以使用reduction。汇总mark1的样本如下。
public class Test {
static class Person {
Person(String name, String subject, String department, Long mark1, Long mark2, Long mark3) {
this.name = name;
this.subject = subject;
this.department = department;
this.mark1 = mark1;
this.mark2 = mark2;
this.mark3= mark3;
}
String name;
String subject;
String department;
Long mark1;
Long mark2;
Long mark3;
String group() {
return subject+department;
}
Long getMark1() {
return mark1;
}
}
public static void main(String[] args)
{
List<Person> list = new ArrayList<Test.Person>();
list.add(new Test.Person("Clark","English","DEP1",7l,8l,6l));
list.add(new Test.Person("Michel","English","DEP1",6l,4l,7l));
list.add(new Test.Person("Dave","Maths","DEP2",3l,5l,6l));
list.add(new Test.Person("Mario","Maths","DEP1",9l,7l,8l));
Map<String, Long> groups = list.stream().collect(Collectors.groupingBy(Person::group, Collectors.reducing(
0l, Person::getMark1, Long::sum)));
//Or alternatively as suggested by Holger
Map<String, Long> groupsNew = list.stream().collect(Collectors.groupingBy(Person::group, Collectors.summingLong(Person::getMark1)));
System.out.println(groups);
}
}
仍在研究通过单一功能生成输出。将在完成后更新。
答案 1 :(得分：3)
在JDK中使用标准收集器，你可以这样做（假设创建了一个Tuple3<E1, E2, E3>类）：
Map<String, Map<String, Tuple3<Long, Long, Long>>> res =
persons.stream().collect(groupingBy(p -> p.subject,
groupingBy(p -> p.department,
reducing(new Tuple3<>(0L, 0L, 0L),
p -> new Tuple3<>(p.mark1, p.mark2, p.mark3),
(t1, t2) -> new Tuple3<>(t1.e1 + t2.e1, t1.e2 + t2.e2, t1.e3 + t2.e3)))));
这将首先按主题分组元素，然后按部门分组，并通过对其标记求和来减少第二个地图中的结果值。
在您的示例中的人员列表中运行它，您将获得输出：
Maths => DEP2 => (3, 5, 6)
Maths => DEP1 => (9, 7, 8)
English => DEP1 => (13, 12, 13)
在这种情况下，您可能还想使用toMap收集器使用另一个变体。逻辑保持不变，映射值的功能将创建一个包含部门作为关键字的地图，并将学生的等级作为值。合并功能将负责添加或更新映射。
Map<String, Map<String, Tuple3<Long, Long, Long>>> res3 =
persons.stream()
.collect(toMap(p -> p.subject,
p -> {
Map<String, Tuple3<Long, Long, Long>> value = new HashMap<>();
value.put(p.department, new Tuple3<>(p.mark1, p.mark2, p.mark3));
return value;
},
(v1, v2) -> {
v2.forEach((k, v) -> v1.merge(k, v, (t1, t2) -> new Tuple3<>(t1.e1 + t2.e1, t1.e2 + t2.e2, t1.e3 + t2.e3)));
return v1;
}
));
当然，你可以质疑自己的美丽＆＃34;在这些解决方案中，您可能希望引入自定义收集器或自定义类，以使意图更加清晰。
答案 2 :(得分：1)
使用Group by multiple field names in java 8的方法和自定义密钥类，我的建议如下：
Map<DepSubject, Grades> map = persons.stream().
collect(Collectors.groupingBy(x -> new DepSubject(x.department, x.subject),
Collectors.reducing(
new Grades(0, 0, 0),
y -> new Grades(y.mark1, y.mark2, y.mark3),
(x, y) -> new Grades(x.m1 + y.m1, x.m2 + y.m2, x.m3 + y.m3)
)));
DepSubject定义equals和hashCode。这样就不必更改原始类，如果需要多个分组标准，则可以使用多个类。不幸的是，这在Java中可能非常冗长，因为你需要一个带有equals，hashCode，（getters，setters）的类。实际上，在我看来，如果该类仅在一个地方用于分组，那么也可以省略getter和setter。
class DepSubject{
String department;
String subject;
public DepSubject(String department, String subject) {
this.department = department;
this.subject = subject;
}
public String getDepartment() {
return department;
}
// equals,hashCode must also be defined for this to work, omitted for brevity
}
也可以将结果收集到List中。这样，自定义类DepSubject和Grades仅用于中间操作：
List<Person> list = persons.stream().
collect(Collectors.collectingAndThen(
Collectors.groupingBy(x -> new DepSubject(x.department, x.subject),
Collectors.reducing(
new Grades(0, 0, 0),
y -> new Grades(y.mark1, y.mark2, y.mark3),
(x, y) -> new Grades(x.m1 + y.m1, x.m2 + y.m2, x.m3 + y.m3)
)),
map -> map.entrySet().stream()
.map(e -> new Person(null, e.getKey().subject, e.getKey().department, e.getValue().m1, e.getValue().m2, e.getValue().m3))
.collect(Collectors.toList())
));
您还可以将groupingBy逻辑提取到函数中：
private static <T> List<Person> groupBy(List<Person> persons, Function<Person,T> function, BiFunction<T,Grades,Person> biFunction) {
return persons.stream().
collect(Collectors.collectingAndThen(
Collectors.groupingBy(function,
Collectors.reducing(
new Grades(0, 0, 0),
y -> new Grades(y.mark1, y.mark2, y.mark3),
(x, y) -> new Grades(x.m1 + y.m1, x.m2 + y.m2, x.m3 + y.m3)
)),
map -> map.entrySet().stream()
.map(e -> biFunction.apply(e.getKey(),e.getValue()))
.collect(Collectors.toList())
));
}
这样，您可以通过这种方式对您的人员进行分组：
List<Person> list = groupBy(persons,
x -> new DepSubject(x.department, x.subject),
(depSubject,grades) -> new Person(null, depSubject.subject, depSubject.department, grades.m1, grades.m2, grades.m3));
如果您只想按主题对对象进行分组，您可以这样做：
List<Person> list2 = groupBy(persons,
Person::getSubject,
(subject,grades) -> new Person(null,subject, null, grades.m1, grades.m2, grades.m3));