如何在ListObject2USRing流Java 8上迭代ListObjectOne

我有两个不同的列表，第一个是列表，第二个是列表 List studentList=new ArrayList（）； List moduleList=新建ArrayList（）

如何在studentList上迭代ModuleList，以便您可以看到哪个学生通过了哪个模块

班级学生{

private String studentId;
private String name;
private Type gender;
private String studClass;
private String education;
private HashMap<String, Module> faillOrPass;

public Student()
{
    faillOrPass = new HashMap<String, Module>();
}

public Student (String studentId, String name, Type gender, String studClass, String education)
{
    faillOrPass = new HashMap<String, Module>();
    setStudentId(studentId);
    setName(name);
    setGender(gender);
    setStudClass(studClass);
    setEducation(education);
}

public enum Type { MALE, FAML}

// getters and setters
// equals() and hashCode()
// toString()

} 公共类TestClass{

final static Student st = new Student();
static String ZAYNUL = st.setVolledigeNaam("Zaynul Zaini");
static String PIPO = st.setVolledigeNaam("Pipo");
static String SANNY = st.setVolledigeNaam("Sanny Saniwich");
static String JOHAN = st.setVolledigeNaam("Johan Ginger");
static String DURSAH = st.setVolledigeNaam("Dursah Pikobillo");
static String ROMAN = st.setVolledigeNaam("Roman Romanawich");
static String TOM = st.setVolledigeNaam("Johonson");
static String ANDRE = st.setVolledigeNaam("Andersons");

public static List<Vak> getModuleList() {
    return List.of(

            new Vak(ZAYNUL, "IT", 8, 2020),
            new Vak(SANNY, "IT", 10, 2019),
            new Vak(ROMAN, "IT", 9, 2018),
            new Vak(MALIKA, "IT", 8, 2017),
            new Vak(DURSAH,"IT", 10, 2016),
            new Vak(PIPO,"IT", 10, 2020),

            new Vak(PIPO,"IPC", 5, 2020),
            new Vak(ZAYNUL,"IPC", 6, 2019),
            new Vak(SANNY,"IPC", 4, 2018),
            new Vak(ROMAN,"IPC", 1, 2017),
            new Vak(MALIKA,"IPC", 5, 2016),
            new Vak(DURSAH,"IPC", 4, 2020));
}

public static List<Student> getStudentList() {
    List<Student> listVak = new ArrayList<>();
    listVak.add(new Student("011", ZAYNUL, Student.Type.MALE, "first year", "Architecture"));
    listVak.add(new Student("012", MALIKA, Student.Type.FEMALE, "second year", "economics"));
    listVak.add(new Student("013", SANNY, Student.Type.FEMALE, "third year", "IT"));
    listVak.add(new Student("014", ROMAN, Student.Type.MALE, "fourth year", "Astronomy"));
    listVak.add(new Student("015", TOM, Student.Type.MALE, "second year", "economics"));
    listVak.add(new Student("016", ANDRE, Student.Type.FEMALE, "third year", "IT"));
    listVak.add(new Student("017", JOHAN, Student.Type.MALE, "fourth year", "Astronomy"));
    return listVak;
}

public static void  getPassedAndFaillModule(List<Student> listSt, List<Module> listVak) {

    List<Student> filteredList = listSt.stream()
            .filter(student -> listVak.stream()
                    .filter(md -> md.getCijfer() > 5)
                    .anyMatch(mdo -> mdo.getStudentName() !=null
                            && student.getVolledigeNaam().equals(mdo.getStudentName())))
            .collect(Collectors.toList());
    filteredList.forEach(x -> System.out.println(x));

}

public static void main(String[] args) {
    System.out.println("Print the result: ");
    getPassedAndFaillModule(getStudentList(), getModuleList());
}

final static Student st=new Student（）；
静态字符串ZAYNUL=st.setVolledigeNaam（“ZAYNUL-Zaini”）；
静态字符串PIPO=st.setVolledigeNaam（“PIPO”）；
静态字符串SANNY=st.setVolledigeNaam（“SANNY-Saniwich”）；
静态字符串JOHAN=st.setVolledigeNaam（“JOHAN Ginger”）；
静态字符串DURSAH=st.setVolledigeNaam（“DURSAH-Pikobillo”）；
静态字符串ROMAN=st.setVolledigeNaam（“ROMAN Romanawich”）；
静态字符串TOM=st.setVolledigeNaam（“Johonson”）；
静态字符串ANDRE=st.setVolledigeNaam（“安德森”）；
公共静态列表getModuleList（）{
返回列表(
新瓦克（扎伊努尔，“IT”，2020年8月），
new Vak（桑尼，“IT”，2019年10月10日），
new Vak（罗马“IT”，2018年9月9日），
新Vak（马利卡，“IT”，2017年8月8日），
新Vak（DURSAH，“IT”，2016年10月），
新Vak（PIPO，“IT”，2020年10月），
新Vak（PIPO，“IPC”，2020年5月），
新Vak（扎伊努尔，“IPC”，2019年6月），
新Vak（桑尼，“IPC”，2018年4月），
新Vak（罗马语，“IPC”，2017年1月1日），
新Vak（MALIKA，“IPC”，2016年5月），
新Vak（DURSAH，“IPC”，2020年4月）；
}
公共静态列表getStudentList（）{
List listVak=new ArrayList（）；
listVak.add（新生（“011”，ZAYNUL，Student.Type.MALE，“一年级”，“建筑”）；
listVak.add（新生（“012”，MALIKA，Student.Type.FEMALE，“二年级”，“经济学”）；
listVak.add（新生（“013”，SANNY，Student.Type.femal，“三年级”，“IT”）；
listVak.add（新生（“014”，ROMAN，Student.Type.MALE，“四年级”，“天文学”）；
listVak.add（新生（“015”，TOM，Student.Type.MALE，“二年级”，“经济学”）；
listVak.add（新生（“016”，ANDRE，Student.Type.femal，“三年级”，“IT”）；
listVak.add（新生（“017”，JOHAN，Student.Type.MALE，“四年级”，“天文学”）；
返回listVak；
}
公共静态无效GetPassedAndFailModule（列表列表ST、列表VAK）{
List filteredList=listSt.stream（）
.filter（student->listVak.stream（）
.filter（md->md.getCijfer（）>5）
.anyMatch（mdo->mdo.getStudentName（）！=null
&&student.getVolledigeNaam（）.equals（mdo.getStudentName（）））
.collect（Collectors.toList（））；
filteredList.forEach（x->System.out.println（x））；
}
公共静态void main（字符串[]args）{
System.out.println（“打印结果：”）；
GetPassedAndFailModule（getStudentList（），getModuleList（））；
}

}

这是我得到的结果，但并不好

打印结果： StudentImpl{studentnummer='011'，volledigeNaam='Zaynul Zaini'，type='MALE'，klaas='第一年'，studierichting='Architecture'，vakkenLijst={}

StudentImpl{studentnummer='012'，volledigeNaam='Malika Ginger'，type='Femal'，klaas='second year'，studierichting='economics'，vakkenLijst={}

StudentImpl{studentnummer='013'，volledigeNaam='Sanny Saniwich'，type='Femal'，klaas='三年级'，Studieriching='IT'，vakkenLijst={}

---

StudentImpl{studentnummer='014'，volledigeNaam='Roman Romanawich'，type='MALE'，klaas='四年级'，studierichting='天文学'，vakkenLijst={}

这里的主要问题是代码的不完整部分无法表示，相关的类和部分缺失（例如，

StudentImpl

和

vakkenLijst

，

Vak

）

可能需要进行以下重构：

• 在课堂上，学生提供模块列表（可能不是冗余的

  failOrPass

  map），并将其包含在

  toString（）

  方法中：

班级学生{
私有列表模块；
公共列表getModules（）{
返回此文件。模块；
}
公共void setModules（列表）{
这个.modules=列表；
}
@凌驾
公共字符串toString（）{
返回名称+“：”+模块；
}
}

• 从

  Vak

  类的实例在

  模块中实现复制式构造函数：

类模块{
字符串模块；
国际等级；
国际年；
公共模块（Vak Vak）{
这（vak.getModule（），vak.getGrade（），vak.getYear（））；
}
公共模块（字符串代码、整数级、整数年）{
设置模块（代码）；
职等(职系);；
设定年份（年）；
}
//接受者/接受者/等。
@凌驾
公共字符串toString（）{
返回字符串.格式（“模块：%s，年级=%d，年份=%d”，模块，年级，年份）；
}
}

• 重命名方法

  getpassedandfailmodule

  -getter不应具有

  void

  返回类型：

public static void fillvakdataforstudent（列出学生，列出vak）{
学生。forEach（s->
s、 集合模块(
vaks.stream（）
//.filter（v.getGrade（）>5）//可选地按级别进行筛选
.filter（v->v.getStudentName（）.equals（s.getName（）））
.map（Module:：new）//使用类似复制的构造函数
.collect（收集器.toList（））
)
);
forEach（System.out:：println）；
}

然后，对于缩短的测试数据（没有不必要的

学生

）结果如下：

静态字符串ZAYNUL=“ZAYNUL Zaini”； 静态字符串PIPO=“PIPO”； 静态字符串SANNY=“SANNY Saniwich”； 静态字符串JOHAN=“JOHAN Ginger”； 静态字符串DURSAH=“DURSAH Pikobillo”； 静态字符串ROMAN=“ROMAN Romanawich”； 静态字符串TOM=“Johonson”； 静态字符串ANDRE=“Anderson”； 公共静态列表getVakList（）{ 返回列表( 新瓦克（扎伊努尔，“IT”，2020年8月）， 新瓦克（桑尼，“IT”，10，20

final static Student st = new Student();
static String ZAYNUL = st.setVolledigeNaam("Zaynul Zaini");
static String PIPO = st.setVolledigeNaam("Pipo");
static String SANNY = st.setVolledigeNaam("Sanny Saniwich");
static String JOHAN = st.setVolledigeNaam("Johan Ginger");
static String DURSAH = st.setVolledigeNaam("Dursah Pikobillo");
static String ROMAN = st.setVolledigeNaam("Roman Romanawich");
static String TOM = st.setVolledigeNaam("Johonson");
static String ANDRE = st.setVolledigeNaam("Andersons");

public static List<Vak> getModuleList() {
    return List.of(

            new Vak(ZAYNUL, "IT", 8, 2020),
            new Vak(SANNY, "IT", 10, 2019),
            new Vak(ROMAN, "IT", 9, 2018),
            new Vak(MALIKA, "IT", 8, 2017),
            new Vak(DURSAH,"IT", 10, 2016),
            new Vak(PIPO,"IT", 10, 2020),

            new Vak(PIPO,"IPC", 5, 2020),
            new Vak(ZAYNUL,"IPC", 6, 2019),
            new Vak(SANNY,"IPC", 4, 2018),
            new Vak(ROMAN,"IPC", 1, 2017),
            new Vak(MALIKA,"IPC", 5, 2016),
            new Vak(DURSAH,"IPC", 4, 2020));
}

public static List<Student> getStudentList() {
    List<Student> listVak = new ArrayList<>();
    listVak.add(new Student("011", ZAYNUL, Student.Type.MALE, "first year", "Architecture"));
    listVak.add(new Student("012", MALIKA, Student.Type.FEMALE, "second year", "economics"));
    listVak.add(new Student("013", SANNY, Student.Type.FEMALE, "third year", "IT"));
    listVak.add(new Student("014", ROMAN, Student.Type.MALE, "fourth year", "Astronomy"));
    listVak.add(new Student("015", TOM, Student.Type.MALE, "second year", "economics"));
    listVak.add(new Student("016", ANDRE, Student.Type.FEMALE, "third year", "IT"));
    listVak.add(new Student("017", JOHAN, Student.Type.MALE, "fourth year", "Astronomy"));
    return listVak;
}

public static void  getPassedAndFaillModule(List<Student> listSt, List<Module> listVak) {

    List<Student> filteredList = listSt.stream()
            .filter(student -> listVak.stream()
                    .filter(md -> md.getCijfer() > 5)
                    .anyMatch(mdo -> mdo.getStudentName() !=null
                            && student.getVolledigeNaam().equals(mdo.getStudentName())))
            .collect(Collectors.toList());
    filteredList.forEach(x -> System.out.println(x));

}

public static void main(String[] args) {
    System.out.println("Print the result: ");
    getPassedAndFaillModule(getStudentList(), getModuleList());
}

Zaynul Zaini: [Module: IT, grade=8, year=2020, Module: IPC, grade=6, year=2019]
Pipo: [Module: IT, grade=10, year=2020, Module: IPC, grade=5, year=2020]
Sanny Saniwich: [Module: IT, grade=10, year=2019, Module: IPC, grade=4, year=2018]
Roman Romanawich: [Module: IT, grade=9, year=2018, Module: IPC, grade=1, year=2017]
Johonson: []
Andersons: []
Johan Ginger: [Module: IT, grade=8, year=2017, Module: IPC, grade=5, year=2016]
Dursah Pikobillo: [Module: IT, grade=10, year=2016, Module: IPC, grade=4, year=2020]