JAVA SE 的一个综合型案例

简述

在控制台实现一个对学生信息的控制。并且自行编写一个仿ArrayList< E >集合的集合

目录

• 实体类
• 自定义集合接口
• 自定义集合实现类
• 过滤器接口
• 比较排序接口
• 服务层面类
• 管理类
• 菜单

实体类

package com.project.entity;

import java.io.Serializable;
import java.util.UUID;

/**
 * Student实体类
 */
public class Student implements Serializable {
    // 学号
    private int id;
    // 姓名
    private String name;
    // 年龄
    private int age;
    // 性别
    private char gender;
    // 班级名
    private String className;
    // java分数
    private double javaScore;
    // html分
    private double htmlScore;
    // spring分
    private double springScore;
    // 总分
    private double totalScore;
    // 自增id
    public static int count = 0; // 扩展、属性不是私有
    // 无参
    public Student() {}
    // 无成绩有参数  基本信息
    public Student(String name, int age, char gender, String className) {
        this.id = ++count;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.className = className;
    }
    // 有成绩,有参构造
    public Student(String name, int age, char gender, String className, double javaScore, double htmlScore, double springScore) {
        this(name,age,gender,className);
        this.javaScore = javaScore;
        this.htmlScore = htmlScore;
        this.springScore = springScore;
        this.totalScore = javaScore + htmlScore + springScore;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public double getJavaScore() {
        return javaScore;
    }

    public void setJavaScore(double javaScore) {
        this.javaScore = javaScore;
        //修改总成绩
        setTotalScore();
    }

    public double getHtmlScore() {
        return htmlScore;
    }

    public void setHtmlScore(double htmlScore) {
        this.htmlScore = htmlScore;
        //修改总成绩
        setTotalScore();
    }

    public double getSpringScore() {
        return springScore;
    }

    public void setSpringScore(double springScore) {
        this.springScore = springScore;
        // 修改总成绩
        setTotalScore();
    }

    public double getTotalScore() {
        return totalScore;
    }
    //修改总分
    private void setTotalScore(){
        this.totalScore = this.htmlScore + this.javaScore + this.springScore;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", className='" + className + '\'' +
                ", javaScore=" + javaScore +
                ", htmlScore=" + htmlScore +
                ", springScore=" + springScore +
                ", totalScore=" + totalScore +
                '}';
    }
}

自定义集合接口

package com.project.util;

/**
 * 增加:
 * add(E e)
 * add(int index,E e)
 * 删除:
 * remove(E e)
 * remove(int index)
 * 改:
 * set(int index,E e)
 * 获取:
 * int size()
 * Object[] toArray();
 * boolean isEmpty();
 * boolean contains(Object o);
 * MyList<E> subList(int start,int index)
 * int indexOf(Object o)
 * int lastIndexOf(Object o)
 * E get(int index)
 * @param <E>
 */
public interface MyList<E> {
    /**
     * 添加方法，添加到元素集合末尾
     * @param e 泛型
     * @return true成功 false失败
     */
    boolean add(E e);

    /**
     * 添加方法，指定下标位置进行添加
     * @param index 指定的下标位置
     * @param e 元素泛型
     * @return true成功 false失败
     */
    boolean add(int index,E e);

    /**
     * 移除方法，指定移除 的元素
     * @param o 元素
     * @return 移除的元素
     */
    E remove(Object o);

    /**
     * 移除方法，指定移除的下标
     * @param index 指定的下标
     * @return 移除的元素
     */
    E remove(int index);

    /**
     * 覆盖方法，替换指定下标的元素
     * @param index 指定的下标
     * @param e 替换的元素
     * @return 被替换的元素
     */
    E set(int  index,E e);

    /**
     * 获取集合中有效元素的个数
     * @return
     */
    int size();

    /**
     * 获取当前集合中,所有元素的Object类型的数组
     *
     * @return Object[] 包含集合中所有的对象
     */
    Object[] toArray();

    /**
     * 判断当前集合是否为空
     * @return 如果一个元素都没有,返回true,有返回false
     */
    boolean isEmpty();

    /**
     * 判断某个对象o在集合中是否存在
     * @param o 需要查找的对象
     * @return 存在true,否则false
     */
    boolean contains(Object o);

    /**
     * 根据需求,返回start到end之间的MyList集合子元素
     * @param start 要求有效的下标范围,不能超过end
     * @param index 要求有效的下标范围,不能小于等于start
     * @return 数据符合要求,返回一个当前集合的子集合。若数据不符合要求，返回NULL
     */
    MyList<E> subList(int start,int index);

    /**
     * 获得指定元素在几何中第一次出现的位置
     * @param o 指定元素
     * @return 找到返回值 返回下标，没找到返回-1
     */
    int indexOf(Object o);

    /**
     * 获取指定元素在集合中最后一次出现的位置
     * @param o 指定的元素
     * @return 找到返回值 返回下表，没找到返回-1
     */
    int lastIndexOf(Object o);

    /**
     * 根据指定的下标位置，获取元素
     * @param index 下标
     * @return 返回对象
     */
    E get(int index);
}

自定义集合实现类

package com.project.util.impl;

import com.project.util.MyList;

import java.util.Arrays;

/**
 * 自定义一个ArrayList类
 * @param <E>
 */
public class MyArrayList<E> implements MyList<E> {
    // 定义一个Object类型数组
    private  Object[] elementData = null;
    // 定义数组默认初始化长度
    private final static int DEFAULT_CAPACITY = 10;
    // 定义一个数组下标标识
    private int size = 0;
    // 无参构造方法
    public MyArrayList(){
        this(DEFAULT_CAPACITY);
    }
    // 有参构造方法
    public MyArrayList(int initCapacity){
        // 判断initCapacity范围
        if(initCapacity <0 || initCapacity> Integer.MAX_VALUE){
            throw new IllegalArgumentException("init param error!");
        }
        elementData = new Object[initCapacity];
    }
    /**
     * 添加方法，添加到元素集合末尾
     *
     * @param e 泛型
     * @return true成功 false失败
     */
    @Override
    public boolean add(E e) {
        // 1.判断数组容量是否需要扩容
        if(size == elementData.length){
            grow(size+1); //每次库容一个
        }
        elementData[size++] = e;
        return true;
    }

    /**
     * 添加方法，指定下标位置进行添加
     *
     * @param index 指定的下标位置
     * @param e     元素泛型
     * @return true成功 false失败
     */
    @Override
    public boolean add(int index, E e) {
        // 判断index是否正常范围
        checkIndex(index);
        if(elementData.length == size){
            grow(size+1);
        }
        //移动for
        for (int i = size;i > index;i--){
            elementData[i] = elementData[i-1];
        }
        size ++;
        elementData[index] = e;
        return true;
    }

    /**
     * 移除方法，指定移除 的元素
     *
     * @param o 元素
     * @return 移除的元素
     */
    @Override
    public E remove(Object o) {
        int record = -1;
        //1.遍历查询元素o是否存在,存在则记录下标
        for(int i=0;i <size;i++){
           if(elementData[i].equals(o)){
               record = i;
               break;
           }
        }
        if(record == -1){
            throw new RuntimeException("no this element!");
        }
        Object e = elementData[record];
        //2.移动数组
        for (int i = record; i < size;i++){
            elementData[i] = elementData[i+1];
        }
        elementData[size] = null;
        size--;
        // 这里可以写一个缩小容量的方法
        return (E)e;
    }

    /**
     * 移除方法，指定移除的下标
     *
     * @param index 指定的下标
     * @return 移除的元素
     */
    @Override
    public E remove(int index) {
        // 查询元素是否存在
        checkIndex(index);
        // 保存该对象
        Object obj = elementData[index];

        // 遍历删除指定
        for (int i = index; i < size;i ++) {
            elementData[i] = elementData[i+1];
        }
        size--;
        // 返回该对象
        return (E)obj;
    }

    /**
     * 覆盖方法，替换指定下标的元素
     *
     * @param index 指定的下标
     * @param e     替换的元素
     * @return 被替换的元素
     */
    @Override
    public E set(int index, E e) {
        //检验下标
        checkIndex(index);
        //存储对应的元素
        Object obj = elementData[index];
        // 修改对应的位置值
        elementData[index] = e;
        // 返回被替换的元素
        return (E)obj;
    }

    /**
     * 获取集合中有效元素的个数
     *
     * @return
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 获取当前集合中,所有元素的Object类型的数组
     *
     * @return Object[] 包含集合中所有的对象
     */
    @Override
    public Object[] toArray() {
        // 将集合转换成数组
        return Arrays.copyOf(elementData,size);
    }

    /**
     * 判断当前集合是否为空
     *
     * @return 如果一个元素都没有, 返回true, 有返回false
     */
    @Override
    public boolean isEmpty() {
        return size==0 ? true:false;
    }

    /**
     * 判断某个对象o在集合中是否存在
     *
     * @param o 需要查找的对象
     * @return 存在true, 否则false
     */
    @Override
    public boolean contains(Object o) {
        for (int i = 0; i < size ; i++) {
            if(elementData[i].equals(o)){
                return true;
            }
        }
        return false;
    }

    /**
     * 根据需求,返回start到end之间的MyList集合子元素
     *
     * @param start 要求有效的下标范围,不能超过end
     * @param index 要求有效的下标范围,不能小于等于start
     * @return 数据符合要求, 返回一个当前集合的子集合。若数据不符合要求，返回NULL
     */
    @Override
    public MyList<E> subList(int start, int index) {
        if (start >= index) throw new IllegalArgumentException("The first parameter should not be greater than the second!");
        checkIndex(index);
        // 复制
        MyList<E> o = new MyArrayList<>();
        // 这里就不用内部类了，直接用遍历赋值
        for(int i = start; i<index;i++){
            o.add((E) elementData[i]);
        }
        return o;
    }

    /**
     * 获得指定元素在几何中第一次出现的位置
     *
     * @param o 指定元素
     * @return 找到返回值 返回下标，没找到返回-1
     */
    @Override
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 获取指定元素在集合中最后一次出现的位置
     *
     * @param o 指定的元素
     * @return 找到返回值 返回下标，没找到返回-1
     */
    @Override
    public int lastIndexOf(Object o) {
        //对于任何非空引用值 x,x.equals(null) 都应返回 false
        if (o == null) {
            for (int i = size; i >0 ; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size; i > 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 根据指定的下标位置，获取元素
     *
     * @param index 下标
     * @return 返回对象
     */
    @Override
    public E get(int index) {
        checkIndex(index);
        return (E)elementData[index];
    }
    /**
     * 指定下标的安全检查! 如果下标值不符合要求抛出异常
     * @param index
     */
    public void checkIndex(int index){
        if(index < 0 || index >= size){
            throw new ArrayIndexOutOfBoundsException(index);
        }
    }
    /**
     * 为底层数组elementData做扩容
     * @param minCapacity 扩容需要的最小容量!
     */
    private void grow(int minCapacity){
        //旧的长度
        int oldCapacity = elementData.length;
        //新的长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 判断是否溢出
        if(newCapacity > Integer.MAX_VALUE - 8){
            // Error的错误
            throw new OutOfMemoryError("collection overflow");
        }
        // 防止1 和 其他以外的情况
        if(newCapacity - oldCapacity <= 0){
            newCapacity = DEFAULT_CAPACITY;
        }
        // 复制数组
        elementData = Arrays.copyOf(elementData,newCapacity);
    }
}

过滤器接口

ackage com.project.util;

/**
 * 过滤器接口
 * @param <E>
 */
public interface MyFilter<E> {
    boolean accept(E e);
}

比较排序接口

package com.project.util;

public interface MyComparator<E> {
    /**
     * 自定义排序方法,方法返回值是int类型
     * @param e1  student 类型
     * @param e2
     * @return
     */
    int compare(E e1,E e2);
}

服务层面类

package com.project.service;

import com.project.entity.Student;
import com.project.manager.StudentManager;

import java.util.Scanner;

public class StudentService {
    // 接收菜单类的请求，执行对应的方法
    // 调用StudentManager,传递数组，插入到底层
    private static Scanner sc = new Scanner(System.in);
    private StudentManager stm = new StudentManager();
    /**
     * 展示所有学生
     */
    public void show(){
        stm.get();
    }

    /**
     * 新增学员的方法
     * 该方法，让用户输入数据!并判断数据
     */
    public void addStudent(){
        System.out.println("请输入学员姓名");
        String name = sc.next().trim();
        System.out.println("请输入学员年龄");
        int age = sc.nextInt();
        System.out.println("请输入学员性别(男/女)");
        char sex = sc.next().charAt(0);
        System.out.println("请输入学员班级名称");
        String className = sc.next();
        System.out.println("请输入学员JAVA成绩(若没有,则0)");
        double javaScore = sc.nextDouble();
        System.out.println("请输入学员HTML成绩(若没有,则0)");
        double htmlScore = sc.nextDouble();
        System.out.println("请输入学员Spring成绩(若没有,则0)");
        double springScore = sc.nextDouble();
        // 封装成对象
        Student stu = new Student(name,age,sex,className,javaScore,htmlScore,springScore);
        boolean add = stm.add(stu);
        if (add){
            System.out.println("新增成功!");
        }else{
            System.out.println("新增失败!");
        }
    }
    public void addStudent(Student stu){

        boolean add = stm.add(stu);
        if (add){
            System.out.println("新增成功!");
        }else{
            System.out.println("新增失败!");
        }
    }
    /**
     * 根据id查询
     */
    public void getStudyById() {
        //1.判断输入是否正确
        int id = inputId();
        //2.有没有该学员
        Student student = stm.get(id);
        if(student!=null){
            System.out.println("学号为:"+id+"的学员信息:");
            System.out.println("ID"+student.getId());
            System.out.println("姓名"+student.getName());
            System.out.println("性别"+student.getGender());
            System.out.println("班级"+student.getClassName());
            System.out.println("班级"+student.getAge());
            System.out.println("JavaScore"+student.getJavaScore());
            System.out.println("HTMLScore"+student.getHtmlScore());
            System.out.println("SpringScore"+student.getSpringScore());
            System.out.println("--------------------------------------");
        }else{
            System.out.println("学号为:"+id+"的学员不存在");
        }
    }
    /**
     * 根据ID更新修改学员信息
     */
    public void updateStuById() {
        //1.判断输入是否正确
        int id = inputId();
        //2.判断该学员是否存在
        Student student = stm.get(id);
        if(student!=null){
            //学员存在
            // 修改信息
            System.out.println(student.toString());
            int choice = 0;
            boolean flag = true;
            while (flag){
                System.out.println("1.修改学生姓名");
                System.out.println("2.修改学生性别");
                System.out.println("3.修改学生班级");
                System.out.println("4.修改学生年龄");
                System.out.println("5.修改学生JavaScore");
                System.out.println("6.修改学生HTMLScore");
                System.out.println("7.修改学生SpringScore");
                System.out.println("8.退出，并保存");
                System.out.println("请选择");
                choice = sc.nextInt();
                switch (choice){
                    case 1:
                        System.out.println("请输入学生的新姓名:");
                        String name = sc.next();
                        student.setName(name);
                        break;
                    case 2:
                        System.out.println("请输入学生的性别:");
                        char name2 = sc.next().charAt(0);
                        student.setGender(name2);
                        break;
                    case 3:
                        System.out.println("请输入学生的新班级:");
                        String name3 = sc.next();
                        student.setClassName(name3);
                        break;
                    case 4:
                        System.out.println("请输入学生的新年龄:");
                        int name4 = sc.nextInt();
                        student.setAge(name4);
                        break;
                    case 5:
                        System.out.println("请输入学生的新JavaScore:");
                        double name5 = sc.nextDouble();
                        student.setJavaScore(name5);
                        break;
                    case 6:
                        System.out.println("请输入学生的新HTMLScore:");
                        double name6 = sc.nextDouble();
                        student.setHtmlScore(name6);
                        break;
                    case 7:
                        System.out.println("请输入学生的新SpringScore:");
                        double name7 = sc.nextDouble();
                        student.setSpringScore(name7);
                        break;
                    case 8:
                        System.out.println("保存并退出");
                        boolean result = stm.set(id,student);
                        // 替换
                        if(result){
                            System.out.println("修改成功");
                        }else{
                            System.out.println("修改失败");
                        }
                        flag = false;
                        break;
                    case 0:
                        System.out.println("暂未开发，不要违规操作!");
                        break;
                }
            }
        }else{
            //学员不存在
            System.out.println("学号为:"+id+"的学员不存在");
        }
    }
    /**
     * 根据ID删除
     */
    public void deleteStuById() {
        //1.判断输入是否正确
        int id = inputId();
        //2.有没有该学员
        Student student = stm.remove(id);
        if(student!=null){
            System.out.println("学号为:"+id+"的学员删除成功");
            System.out.println(student.toString());
        }else{
            System.out.println("学号为:"+id+"的学员不存在");
        }
    }
    private int inputId(){
        int id = 0;
        System.out.println("请输入学员的ID:");
        do {
            id=sc.nextInt();
            if(id<=0){
                System.out.println("请输入正确的ID");
            }
        }while (id<=0);
        return id;
    }

    /**
     * 根据班级名称查询对应的学员
     */
    public void getStudyByClassName() {
        System.out.println("请输入班级名称");
        String className = sc.next().trim();
        stm.get(className);
    }

    /**
     * 模糊查询
     */
    public void getStudentByLike(){
        int choice = 0;
        while(true){
            System.out.println("请选择:");
            System.out.println("1.根据姓查询 2、根据字典查询 0、退出");
            choice =sc.nextInt();
            switch (choice){
                case 1:
                    System.out.println("根据姓查询");
                    String surname = sc.next();
                    stm.getSurname(surname);
                    break;
                case 2:
                    System.out.println("根据名字");
                    String lastname = sc.next();
                    stm.getLastname(lastname);
                    break;
                case 0:
                    System.out.println("退出!");
                    return; //直接结束方法
            }
        }
    }
    /**
     * 实现学员的排序
     */
    public void sortStu(){
        //1.排序规则 升序
        //2.升序的方式有多种:id、age、score
        //3.底层排序
        int choice = 0;
        while(true){
            System.out.println("将按照升序排列学员信息，请选择条件:");
            System.out.println("1、根据id 2、根据年龄 3、根据score");
            choice = sc.nextInt();
            switch (choice){
                case 1:stm.sort((v,k)->v.getId()-k.getId());break;
                case 2:stm.sort((v,k)->v.getAge()-k.getAge());break;
                case 3:stm.sort((v,k)->(int)((v.getTotalScore()-k.getTotalScore())*100));break;
                case 0:
                    System.out.println("退出");
                    return;
                default:
                    System.out.println("暂未开发!");
                    break;
            }
        }

    }

    /**
     * 过滤方法
     */
    public void showFilter() {
        //1.查询年龄大于15的
        //2.查询总分大于150分的
        int choice = 0;
        while (true){
            System.out.println("请选择过滤规则:");
            System.out.println("1.年龄大于15岁的 2.总分大于150分的");
            choice = sc.nextInt();
            switch (choice){
                case 1:
                    stm.showStuForFilter(v->v.getAge()>15);
                    break;
                case 2:
                    stm.showStuForFilter(v->v.getTotalScore() > 150.00);
                    break;
                case 0:
                    return;

            }
        }
    }

    /**
     * 退出时候写入文件
     */
    public void saveStuForFile() {
        stm.saveByStream();
    }
}

管理类

package com.project.manager;

import com.project.entity.Student;
import com.project.util.MyComparator;
import com.project.util.MyFilter;
import com.project.util.MyList;
import com.project.util.impl.MyArrayList;
import java.io.*;
/**
 * 完成所有学生管理系统的相关功能
 * 逻辑代码、输入数据、
 */
public class StudentManager {
    // 只负责接收前端数据，调用后端
    // 使用自定义的MyArrayList,存储学生对象
    private  MyList<Student> allMyList = null;
    public StudentManager(){
        allMyList = new MyArrayList<>();
        load();
    }

    /**
     * 传入初始容量，创建集合对象，要求数据大于等于0，小于Integer.MAV_VALUE-8如果不满足报错
     * @param initCapacity
     */
    public StudentManager(int initCapacity){
        allMyList = new MyArrayList<>(initCapacity);
        load();
    }
    /**
     * 添加学生对象的方法，采用尾插法，插入到集合的末端
     * @param stu Student 类对象
     * @return  添加学生成功返回true,反之,false
     */
    public boolean add(Student stu){
        if(stu == null){
            System.out.println("存入的学生不能为空对象");
            return false;
        }
        this.allMyList.add(stu);
        return true;
    }

    /**
     * 根据学生的唯一ID,删除指定的学生
     * @param studentId  要删除的学生编号
     * @return  删除的学生对象
     */
    public Student remove(int studentId){
        //1.检查id在几何中的下标位置
        int index = findIndexById(studentId);
        try {
            return allMyList.remove(index);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());
        }
        return null;
    }
    /**
     * 查单个
     * @param studentId
     * @return
     */
    public Student get(int studentId){
        //1.判断下标的数值正确
        int n = findIndexById(studentId);
        if(n!=-1){
            //2.在获得学员 对象返回给StudentService
            return allMyList.get(n);
        }
        return null;
    }

    /**
     * 根据学员的id，查询该学生在集合中的下标位置
     * @param studentId 查询的id
     * @return 存在的话返回大于等于0的数字，没有找到，返回-1
     */
    private int findIndexById(int studentId){
        int index = -1; //学员在集合中的下标位置
        //从下标0开始遍历集合
        for (int i = 0;i<allMyList.size();i++){
            //依此获取当前学生对象的id和传入的StudentId作比较
            if(allMyList.get(i).getId() == studentId){
                index = i;
                break;
            }
        }
        return index;
    }
    /**
     * 查询所有，直接遍历集合
     */
    public void get(){
        // 打印所有学生信息
        for (int i =0; i < allMyList.size();i++){
            System.out.println(allMyList.get(i));
        }
    }

    /**
     * 根据班级名称，查询学生列表
     * @param className className
     */
    public void get(String className){
        for (int i = 0; i < allMyList.size() ; i++) {
            if(allMyList.get(i).getClassName().equals(className)){
                System.out.println(allMyList.get(i).toString());
            }
        }
    }

    /**
     * 根据姓式查找
     * @param surname
     */
    public void getSurname(String surname){
        for (int i = 0; i < allMyList.size() ; i++) {
            if(allMyList.get(i).getName().startsWith(surname)){
                System.out.println(allMyList.get(i).toString());
            }
        }
    }
    /**
     * 根据名字模糊查询
     * @param lastname
     */
    public void getLastname(String lastname){
        for (int i = 0; i < allMyList.size() ; i++) {
            if(allMyList.get(i).getName().contains(lastname)){
                System.out.println(allMyList.get(i).toString());
            }
        }
    }
    /**
     * 修改覆盖
     */
    public boolean set(int studentId,Student stu){
        int index = findIndexById(studentId);
        Student set = allMyList.set(index, stu);
        if(set==null){
            return false;
        }
        return true;
    }

    public void sort(MyComparator<Student> com){
        Object[] objects = allMyList.toArray();
        // 选择排序
        for (int i = 0; i < objects.length-1 ; i++) {
            for (int j = i+1; j <objects.length ; j++) {
                // 是升序
                if(com.compare((Student)objects[i],(Student)objects[j])>0){
                    Student temp = (Student)objects[i];
                    objects[i] = objects[j];
                    objects[j] = temp;
                }
            }
        }
        for (Object obj:objects){
            System.out.println(obj);
        }
    }

    /**
     *
     */
    public void showStuForFilter(MyFilter<Student> filter) {
        for (int i = 0; i <allMyList.size() ; i++) {
            if (filter.accept(allMyList.get(i))){
                System.out.println(allMyList.get(i));
            }
        }
    }
    public void saveByStream(){
        File file = new File("D:\\data.txt");
        try(
              FileOutputStream fis = new FileOutputStream(file);
              ObjectOutputStream  ois = new ObjectOutputStream(fis);) {
                for (int i = 0; i <allMyList.size() ; i++) {
                    Student stu = allMyList.get(i);
                    ois.writeObject(stu);
                    ois.flush();
                }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public void load() {
        try {
            File file = new File("D:\\data.txt");
            if(file.exists() && file.length()>0){
                FileInputStream fis = new FileInputStream(file);
                ObjectInputStream ois = new ObjectInputStream(fis);
                int max = 0;
                while(true){
                    Object obj;
                    try{
                        obj = ois.readObject();
                        Student student = (Student)obj;
                       if(student.getId()>max){
                           max = student.getId();
                       }
                    }catch (Exception e) {
                        break;
                    }
                    allMyList.add((Student)obj);
                    Student.count = max;
                }
            }else{
                System.out.println("为了避免出错，创建一个文件！");
                file.createNewFile();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch(IOException e){

        }

    }
}

菜单类

package com.project.SystemMain;
import com.project.entity.Student;
import com.project.service.StudentService;
import java.util.Scanner;


public class SystemMain {
    static Scanner sc = new Scanner(System.in);
    private static StudentService ss = new StudentService();
    public static void main(String[] args) {
//        for (int i = 0; i <10 ; i++) {
//            String name="吴彦祖"+i;
//            int age = (int)(Math.random()*5);
//            char sex = '男';
//            String className = "nz2002";
//            double javaScore = 0;
//            double htmlScore = 0;
//            double springScore = 0;
//
//            ss.addStudent(new Student(name,age,sex,className,javaScore,htmlScore,springScore));
//            //String name, int age, char gender, String className, double javaScore, double htmlScore, double springScore
//        }
        // 默认选择
        int choice = 0;
        while (true){
            System.out.println("欢迎来到某某系统!");
            System.out.println("1.查看所有");
            System.out.println("2.新增");
            System.out.println("3.查询指定ID的学生信息");
            System.out.println("4.根据ID修改学员");
            System.out.println("5.根据ID删除学员");
            System.out.println("6.根据班级名称查询学员");
            System.out.println("7.根据姓名(姓、名)查询学员");
            System.out.println("8.根据需求排序学员信息");
            System.out.println("9.根据需求展示符合条件的学员信息");
            System.out.println("0.退出");
            System.out.println("请选择:");

            choice = sc.nextInt();
            switch (choice){
                case 1: //查看所有
                    ss.show();
                    break;
                case 2: //新增
                    ss.addStudent();
                    break;
                case 3:
                    ss.getStudyById();
                    break;
                case 4:
                    ss.updateStuById();
                    break;
                case 5:
                    ss.deleteStuById();
                    break;
                case 6:
                    ss.getStudyByClassName();
                    break;
                case 7:
                    ss.getStudentByLike();
                    break;
                case 8:
                    ss.sortStu();
                    break;
                case 9:
                    ss.showFilter();
                    break;
                case 0: // 退出
                    ss.saveStuForFile();
                    System.out.println("退出该程序");
                    return;
                default: break;
            }

        }
    }
}