Lambda 如果一个对象有两个或多个不同的列表，如何在流Java8中迭代？

这是我想要设置数据的模型

public class StudentMarksModel {
    private String studentName;
    private Integer totalmarks;


    public StudentMarksModel(String studentName, Integer totalmarks) {
        super();
        this.studentName = studentName;
        this.totalmarks = totalmarks;
    }
// getter setter .....  

}

这是我的实体

@Document(collection = "studentmarks")
    public class StudentMaksEntity {
        @Id
        private String id;
        @Field("studentid")
        private String studentid;

        @Field("studentname")
        private String studentname;

        @Field("subjectMarks")
        private List<SubjectMarks> subjectMarks;

       // getter setter

    }

在上面的代码中，我必须使用两个不同的流，但我想在一个流中完成

比如说

list.stream().map(s -> s.getSubjectMarks())
                  .flatMap(List::stream)
                .map(p -> new StudentMarksModel("here i want name of student",p.getAllmarks().entrySet().stream().mapToInt(l -> l.getValue().intValue()).sum()))
                .collect(Collectors.toList());

---

看看你正在使用的方法。对于

listofName

，它是：

stream -> map -> collect

stream -> map -> flatMap -> map -> collect

对于

litsOfsumOfMarks

它是：

stream -> map -> collect

stream -> map -> flatMap -> map -> collect

方法

map

将保留元素的数量，但是

flatMap

不必这样做。这意味着列表

listofName

和

litsOfsumOfMarks

的大小可能不同。如果您确定使用的

flatMap

始终返回大小为1的流，则可以轻松地将其替换为

map

当您确定两个流包含相同数量的元素时，您可以合并它们，例如使用辅助类

对

，这样您就可以

list.stream()
    .map(el -> new Pair(<A>, <B>))
    // additional operations on either A, B or A & B
    .map(p -> new StudentMarksModel(p.getA(), p.getB()))

list.stream（）
.map（el->新对（，））
//A、B或A&B上的附加操作
.map（p->new StudentMarksModel（p.getA（），p.getB（））

我希望这就是您想要的：

List<StudentMarksModel> studentMarksModels = list.stream()
                   .map(mp -> {
                        int sum = mp.getSubjectMarks()
                                    .stream()
                                    .flatMap((SubjectMarks t) -> 
                                             t.getAllmarks().values().stream())
                                    .mapToInt(q -> q.intValue()).sum();
                        return new StudentMarksModel(mp.getStudentname(), sum);
        }).collect(Collectors.toList());

List studentMarksModels=List.stream（）
.map（mp->{
int sum=mp.getSubjectMarks（）
.stream（）
.flatMap（（主题标记t）->
t、 getAllmarks（）.values（）.stream（））
.mapToInt（q->q.intValue（））.sum（）；
返回新的StudentMarksModel（mp.getStudentname（），sum）；
}).collect（Collectors.toList（））；

显示StudentMarksEntity和StudentMarksModel以更好地说明您的描述并帮助其他人帮助您。您的

LitsOfMarks

将所有学生科目

s1->[sub1，sub2，sub3…]，s2->[sub11，sub12…]

合并为一个流

（sub1->sub2->sub3->sub11->sub12…

，然后对每个主题求和该主题的所有分数，现在剩下

（sub1mark->sub2mark->sub3mark->sub11mark->sub12mark…

）。这如何让你知道哪个分数属于哪个学生？下面是你做的

litsOfsumOfMarks.get（p）

，但是你刚刚得到的分数可能属于错误的学生！在任何情况下，您都应该查看

Collectors#groupingBy

@Aominè谢谢您的回复我已经更新了我的帖子。@smack89谢谢您的回复。。。我提升了我的职位。现在我想说的话可能已经很清楚了。谢谢你的回复。。。我提升了我的职位。现在我想说的可能已经很清楚了。谢谢你们，但按照代码标准，地图里的花括号会让它看起来很难看。我在某处读到了这个编码标准。

stream -> map -> flatMap -> map -> collect

list.stream()
    .map(el -> new Pair(<A>, <B>))
    // additional operations on either A, B or A & B
    .map(p -> new StudentMarksModel(p.getA(), p.getB()))

List<StudentMarksModel> studentMarksModels = list.stream()
                   .map(mp -> {
                        int sum = mp.getSubjectMarks()
                                    .stream()
                                    .flatMap((SubjectMarks t) -> 
                                             t.getAllmarks().values().stream())
                                    .mapToInt(q -> q.intValue()).sum();
                        return new StudentMarksModel(mp.getStudentname(), sum);
        }).collect(Collectors.toList());