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;
            }

        }
    }
}