Java实验（4）集合与函数式编程

一、实验目的
1.掌握集合的基本操作方法
2.掌握Lambda表达式的声明编写规范
3.掌握基于集合Stream的过滤/映射/聚合等操作
4.掌握基于函数式编程集合元素的移除方法

1、实验的目的是掌握集合流操作，按指导书说明直接复制使用entity/DatabaseUtils/Service等代码
写接口实现类，按要求实现接口中方法，编写测试类测试数据，测试。
2、文件列表

3、
（1）Student类代码：

package com.experiment04.entity;

public class Student {
    public enum Sex {
        MALE, FEMALE
    }

    private int id;
    private Sex sex;
    private String name;
    // 例如2017级
    private int year;

    public Student(int id, Sex sex, String name, int year) {
        this.id = id;
        this.sex = sex;
        this.name = name;
        this.year = year;
    }

    public int getId() {
        return id;
    }

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

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

（2）、DatebaseUtils类代码：

package com.experiment04.resource;

import com.experiment04.entity.Student;

import java.util.ArrayList;
import java.util.List;

public class DatabaseUtils {
    private static final List<Student> STUDENTS = create();
    private static List<Student> create() {
        List<Student> students = new ArrayList<>();
        students.add(new Student(201001, Student.Sex.FEMALE, "赵阳阳", 2010));
        students.add(new Student(201002, Student.Sex.MALE, "邵鹏", 2010));
        students.add(new Student(201103, Student.Sex.MALE, "高学斌", 2011));
        students.add(new Student(201104, Student.Sex.MALE, "张扬", 2011));
        students.add(new Student(201205, Student.Sex.FEMALE, "吕惠玲", 2012));
        students.add(new Student(201206, Student.Sex.MALE, "曾志优", 2012));
        return students;
    }

    public static List<Student> getStudents() {
        return STUDENTS;
    }
}

（3）、StudentService接口代码：

package com.experiment04.service;

import com.experiment04.entity.Student;

import java.util.List;
import java.util.Map;

public interface StudentService {
    /**
     * 向集合添加一个学生，返回当前全部学生
     * @param student
     * @return
     */
    List<Student> addStudent(Student student);

    /**
     * 返回指定届的全部学生
     * @param year
     * @return
     */
    List<Student> listStudentsByYear(int year);

    /**
     * 返回指定届，指定性别的全部学生的姓名
     * @param year
     * @param sex
     * @return
     */
    List<String> listStudentsNames(int year, Student.Sex sex);

    /**
     * 将所有学生，以性别分组
     * @return
     */
    Map<Student.Sex, List<Student>> mapStudentsBySex();

    /**
     * 删除指定学号的学生，返回是否成功删除
     * @param id
     * @return
     */
    boolean removeStudent(int id);
}

以上代码均直接从老师的github复制而来。
实验内容主要是实现StudentService接口中的方法，完善所需要功能。
（4）、StudentServiceImpl类代码：

package com.experiment04.service.impl;

import com.experiment04.entity.Student;
import com.experiment04.resource.DatabaseUtils;
import com.experiment04.service.StudentService;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StudentServiceImpl implements StudentService {
    /**
     * 向集合添加一个学生，返回当前全部学生
     *
     * @param student
     * @return
     */
    public List<Student> addStudent(Student student) {
        List<Student> list = DatabaseUtils.getStudents();
        list.add(student);
        return list;
    }

    /**
     * 返回指定届的全部学生
     *
     * @param year
     * @return
     */

    public List<Student> listStudentsByYear(int year) {
        List<Student> list = DatabaseUtils.getStudents();
                return list.stream()//转化为流操作
                .filter(s->s.getYear()==year)
                .collect(Collectors.toList());
    }

    /**
     * 返回指定届，指定性别的全部学生的姓名
     *
     * @param year
     * @param sex
     * @return
     */
    public List<String> listStudentsNames(int year, Student.Sex sex) {
        List<Student> list = DatabaseUtils.getStudents();
        return list.stream()
                .filter(s->s.getYear()==year&&s.getSex().equals(sex))
                .map(Student::getName)
                .collect(Collectors.toList());
    }
    /**
     * 将所有学生，以性别分组
     *
     * @return
     */
    public Map<Student.Sex, List<Student>> mapStudentsBySex() {
        Map<Student.Sex, List<Student>> map = new HashMap<>();
        List<Student> male_list = new ArrayList<>();
        List<Student> female_list = new ArrayList<>();
        map.put(Student.Sex.MALE, male_list);
        map.put(Student.Sex.FEMALE, female_list);
        List<Student> list = DatabaseUtils.getStudents();
        for (Student stu : list) {
            if (stu.getSex().equals(Student.Sex.MALE)) {
                map.get(Student.Sex.MALE).add(stu);
            }
            if (stu.getSex().equals(Student.Sex.FEMALE)) {
                map.get(Student.Sex.FEMALE).add(stu);
            }
        }
        return map;
    }

    /**
     * 删除指定学号的学生，返回是否成功删除
     *
     * @param id
     * @return
     */
    public boolean removeStudent(int id) {
        List<Student> list=DatabaseUtils.getStudents();
        for(Student stu:list){
            if(stu.getId()==id){
                list.remove(stu);
                return true;
            }
        }
        return false;
    }//可以基于流操作，更加简便。

}

(5)、代码测试Test类：

package com.experiment04;

import com.experiment04.entity.Student;
import com.experiment04.resource.DatabaseUtils;
import com.experiment04.service.impl.StudentServiceImpl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        Test t=new Test();
        t.getStudent();
        StudentServiceImpl test=new StudentServiceImpl();

        //1、向原库中添加 两位学生
        test.addStudent(new Student(2019214233,Student.Sex.MALE,"张兵",2019));
        test.addStudent(new Student(2019214234,Student.Sex.MALE,"张杨",2019));
        System.out.println("添加后:");
        t.getStudent();

        //2、返回2011年的学生
        List<Student> year_list=test.listStudentsByYear(2011);
        System.out.println("2011年的学生:");
        for(Student stu:year_list){
            System.out.println(stu.getName());
        }

        //3、返回指定届，指定性别的全部学生的姓名
        List<String> name_list=test.listStudentsNames(2011,Student.Sex.MALE);
        System.out.println("2011年 性别为MALE的学生:");
        for(String name:name_list){
            System.out.println(name);
        }
        //4、学生以性别分组
        System.out.println("分组后:");
        Map<Student.Sex,List<Student>> map=new HashMap<>();
        map=test.mapStudentsBySex();
        for(Student.Sex key:map.keySet()){
            System.out.println("性别"+key+":");
            List<Student> list=map.get(key);
            for(Student student:list)
                System.out.println(student.getName());
        }

        //5、删除指定学号学生
        test.removeStudent(201206);
        System.out.println("删除后:");
        t.getStudent();
    }
    public void getStudent(){
        List<Student> list= DatabaseUtils.getStudents();
        for(Student stu:list){
            System.out.println(stu.getId()+" "+stu.getSex()+" "+stu.getYear()+" "+stu.getName());
        }
    }
}

本实验也可以基于集合判断等方法完成，但是与基于流的函数式编程相比，代码冗长，繁琐，需要多次判断转型。所以使用基于流的函数式编程，有利于简化代码。