学生成绩档案管理系统（Java代码实现）

港控/mmm° 2023-10-05 21:25 9阅读 0赞

### 文章目录 ###

*   *  一、学生信息类（pojo包）
     *   *  1.StudentNode类
         *  2.代码如下
     *  二、数据访问对象类（dao包）
     *   *  1.StudentDao类
         *  2.代码如下
     *  三、系统服务端类（Service包）
     *   *  1.StudentService类
         *  2.代码如下
     *  四、比较器工具类（tools包）
     *   *  1.Compare类
         *  2.代码如下
     *  五、数据库和文档交互类（data包）
     *   *  1.Database类
         *  2.代码如下
         *  3.ReaderWriter类
         *  4.代码如下
     *  六、排序方法类（sort包）
     *   *  1.BidirectionalBubbleSort类（双向冒泡排序）
         *  2.代码如下
         *  3.ShellSort类（希尔排序）
         *  4.代码如下
         *  5.QuickSort类（快速排序）
         *  6.代码如下
         *  7.HeapSort类（堆排序）
         *  8.代码如下
     *  七、主类（main包）
     *   *  1.main类
         *  2.代码如下
     *  八、学生信息储存文件（student.txt）
     *  九、学生成绩档案系统成果展示

## 一、学生信息类（pojo包） ##

### 1.StudentNode类 ###

### 2.代码如下 ###

package pojo;
    import java.util.Objects;
    public class StudentNode {
        private int id;
        private String name;
        private String major;
        private double A_grade;
        private double B_grade;
        private double C_grade;
        private double D_grade;
        private double all_grade;
        private int sort;
    
        public StudentNode() {
        }
    
        public StudentNode(int id, String name, String major, double A_grade,
                           double B_grade, double C_grade, double D_grade,
                           double all_grade, int sort) {
            this.id = id;
            this.name = name;
            this.major = major;
            this.A_grade = A_grade;
            this.B_grade = B_grade;
            this.C_grade = C_grade;
            this.D_grade = D_grade;
            this.all_grade = all_grade;
            this.sort = sort;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getMajor() {
            return major;
        }
    
        public void setMajor(String major) {
            this.major = major;
        }
    
        public double getMath_grade() {
            return A_grade;
        }
    
        public void setMath_grade(double A_grade) {
            this.A_grade = A_grade;
        }
    
        public double getEnglish_grade() {
            return B_grade;
        }
    
        public void setEnglish_grade(double B_grade) {
            this.B_grade = B_grade;
        }
    
        public double getJava_grade() {
            return C_grade;
        }
    
        public void setJava_grade(double C_grade) {
            this.C_grade = C_grade;
        }
    
        public double getCpp_grade() {
            return D_grade;
        }
    
        public void setCpp_grade(double D_grade) {
            this.D_grade = D_grade;
        }
    
        public void setAll_grade() {
            this.all_grade = this.A_grade + this.B_grade + this.C_grade + this.D_grade;
        }
    
        public double getAll_grade() {
            return all_grade;
        }
    
        public int getSort() {
            return sort;
        }
    
        public void setSort(int sort) {
            this.sort = sort;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            StudentNode that = (StudentNode) o;
            return id == that.id &&
                    Double.compare(that.A_grade, A_grade) == 0 &&
                    Double.compare(that.B_grade, B_grade) == 0 &&
                    Double.compare(that.C_grade, C_grade) == 0 &&
                    Double.compare(that.D_grade, D_grade) == 0 &&
                    Double.compare(that.all_grade, all_grade) == 0 &&
                    Double.compare(that.sort, sort) == 0 &&
                    Objects.equals(name, that.name) &&
                    Objects.equals(major, that.major);
        }
    
    
        public int hashCode() {
            return Objects.hash(id, name, major, A_grade, B_grade,
                    C_grade, D_grade, all_grade, sort);
        }
    
        public String toString() {
            return id + "\t" + name + "\t" + major + "\t  " + A_grade + "\t    " + B_grade + "\t    " +
                    C_grade + "\t    " + D_grade + "\t    " + all_grade + "\t  " + sort;
        }
    }

## 二、数据访问对象类（dao包） ##

### 1.StudentDao类 ###

### 2.代码如下 ###

package dao;
    import data.Database;
    
    public class StudentDao {
        private Database database;
    
        public StudentDao(Database database)
        {
            this.database = database;
        }
    
        public Database getDatabase() {
            return database;
        }
    }

## 三、系统服务端类（Service包） ##

### 1.StudentService类 ###

### 2.代码如下 ###

package service;
    import dao.StudentDao;
    import data.Database;
    import pojo.StudentNode;
    import sort.BidirectionalBubbleSort;
    import sort.HeapSort;
    import sort.QuickSort;
    import sort.ShellSort;
    import tools.Compare;
    
    import java.util.Collections;
    import java.util.Scanner;
    
    public class StudentService {
        private Scanner key = new Scanner(System.in);
        private StudentDao studentDao;
        private BidirectionalBubbleSort bidirectional_bubble_sort = new BidirectionalBubbleSort();
        private HeapSort heap_sort = new HeapSort();
        private QuickSort quick_sort = new QuickSort();
        private ShellSort shell_sort = new ShellSort();
    
        public StudentService(Database database) {
            studentDao = new StudentDao(database);
        }
    
        /**
         * 起始目录
         */
        public void start() {
            System.out.print("******题目一：学生档案管理系统******");
            System.out.println();
            mean();
        }
    
        public void mean() {
            System.out.println("##您可选择的目录如下：        ");
            System.out.println("#1.新增学生信息（包括学号、姓名、专业、4门课成绩）");
            System.out.println("#2.浏览学生信息（对学生排序后信息进行浏览）");
            System.out.println("#3.查找学生信息（查找符合条件的某条记录）");
            System.out.println("#4.保存学生信息（保存学生成绩档案信息到文本文件）");
            System.out.println("#5.加载学生信息（登录系统后将磁盘文件中保存的学生成绩信息读取到内存中）");
            System.out.println("#6.结束");
            System.out.println("请选择：");
            int choice = key.nextInt();
            switch (choice) {
    
                case 1:
                    add();//新增学生信息
                    break;
                case 2:
                    browse();//浏览学生信息
                    break;
                case 3:
                    find();//查找学生信息
                    break;
                case 4:
                    save();//保存学生信息
                    break;
                case 5:
                    load();//加载学生信息
                    break;
                case 6:
                   // exit();
                    System.exit(0); // 退出系统
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    mean();
            }
        }
    
        /**
         * 浏览学生信息
         */
        public void browse() {
            //bidirectional_bubble_sort.sortByAll(studentDao.getDatabase().list);
            //heap_sort.sortByAll(studentDao.getDatabase().list);
            quick_sort.sortByAll(studentDao.getDatabase().list, 0, studentDao.getDatabase().list.size() - 1);
            //shell_sort.sortByAll(studentDao.getDatabase().list);
            System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "A课程成绩" + "\t" +
                    "B课程成绩" + "\t" + "C课程成绩" + "\t" + "D课程成绩" + "\t" + "总成绩" + "\t" + "排名");
            for (StudentNode s : studentDao.getDatabase().list) {
                System.out.println(s.toString());
            }
            // 下一步操作
            operation();
        }
    
        /**
         * 浏览学生信息的后续操作
         */
        public void operation() {
            System.out.println("请输入您的操作：");
            System.out.println("1.修改学生信息");
            System.out.println("2.删除学生信息");
            System.out.println("3.新增学生信息");
            System.out.println("4.返回初始目录");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                    modification();//修改学生信息
                    break;
                case 2:
                    delete();//删除学生信息
                    break;
                case 3:
                    add();//新增学生信息
                    break;
                case 4:
                    mean();
                    //返回主菜单
                    break;
                default:
                    System.out.println("输入错误，请重新输入");
                    operation();
            }
        }
    
        /**
         * 查找需要修改学生的信息
         */
        public void modification() {
            StudentNode student = new StudentNode();
            System.out.println("请输入您要修改的学生学号");
            int id = key.nextInt();
            student = searchById(id);
            if (student == null) {
                System.out.println("没有找到该学生，请重新输入");
                modification();
            } else {
                System.out.println("该学生信息如下:");
                System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "A课程成绩" + "\t" +
                        "B课程成绩" + "\t" + "C课程成绩" + "\t" + "D课程成绩" + "\t" + "总成绩" + "\t" + "排名");
                System.out.println(student.toString());
                //修改学生信息
                modification2(student);
            }
    
        }
    
        /**
         * 确认是否修改
         *
         */
        public void modification2(StudentNode student) {
            System.out.println("请问是否确认修改该学生信息");
            System.out.println("确认请输入1，不确认请输入2");
            String choice = key.next();
            if (choice.equals("1")) {
                // 修改学生信息
                modification3(student);
            } else if (choice.equals("2")) {
                System.out.println("已重新返回学生信息");
                browse();
            } else {
                System.out.println("输入错误，请重新输入!");
                modification2(student);
            }
        }
    
        /**
         * 修改学生信息
         *
         */
        public void modification3(StudentNode student) {
            System.out.println("请输入您要修改的学生成绩");
            System.out.println("1.A课程成绩");
            System.out.println("2.B课程成绩");
            System.out.println("3.C课程成绩");
            System.out.println("4.D课程成绩");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                   // System.out.println("您要修改的项目为A课程成绩");
                    System.out.println("请输入修改后的A课程成绩");
                    double math_grade = key.nextDouble();
                    student.setMath_grade(math_grade);
                    student.setAll_grade();
                    break;
                case 2:
                   // System.out.println("您要修改的项目为B课程成绩");
                    System.out.println("请输入修改后的B课程成绩");
                    double english_grade = key.nextDouble();
                    student.setEnglish_grade(english_grade);
                    student.setAll_grade();
                    break;
                case 3:
                  //  System.out.println("您要修改的项目为C课程成绩");
                    System.out.println("请输入修改后的C课程成绩");
                    double java_grade = key.nextDouble();
                    student.setJava_grade(java_grade);
                    student.setAll_grade();
                    break;
                case 4:
                  //  System.out.println("您要修改的项目为D课程成绩");
                    System.out.println("请输入修改后的D课程成绩");
                    double cpp_grade = key.nextDouble();
                    student.setCpp_grade(cpp_grade);
                    student.setAll_grade();
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    modification3(student);
            }
            modification4(student);
    
        }
    
        /**
         * 是否要继续修改
         *
         */
        public void modification4(StudentNode student) {
            System.out.println("修改成功，请问是否要继续修改");
            System.out.println("是请输入1，否请输入2");
            String choice = key.next();
            if (choice.equals("1")) {
                // 修改学生信息
                modification3(student);
            } else if (choice.equals("2")) {
                System.out.println("为您返回学生信息");
                browse();
            } else {
                System.out.println("输入错误，请重新输入");
                modification4(student);
            }
        }
    
        /**
         * 查找需要删除学生的信息
         */
        public void delete() {
            StudentNode student = null;
            System.out.println("请输入您要删除的学生学号");
            int id = key.nextInt();
            student = searchById(id);
            if (student == null) {
                System.out.println("没有找到该学生，请重新输入");
                delete();
            } else {
                System.out.println("该学生信息如下:");
                System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "A课程成绩" + "\t" +
                        "B课程成绩" + "\t" + "C课程成绩" + "\t" + "D课程成绩" + "\t" + "总成绩" + "\t" + "排名");
                System.out.println(student.toString());
                //删除学生信息
                delete2(student);
            }
        }
    
        /**
         * 确认是否删除
         *
         */
        public void delete2(StudentNode student) {
            System.out.println("请问是否确认删除该学生信息");
            System.out.println("确认请输入1，不确认请输入2");
            String choice = key.next();
            if (choice.equals("1")) {
                // 删除学生信息
                delete3(student);
            } else if (choice.equals("2")) {
                System.out.println("已为您重新返回学生信息");
                browse();
            } else {
                System.out.println("输入错误，请重新输入");
                delete2(student);
            }
        }
    
        /**
         * 删除学生信息
         *
         */
        public void delete3(StudentNode student) {
            studentDao.getDatabase().list.remove(student);
            delete4();
        }
    
        /**
         * 是否要继续删除
         */
        public void delete4() {
            System.out.println("删除成功，请问是否要继续删除?");
            System.out.println("是请输入1，否请输入2");
            String choice = key.next();
            if (choice.equals("1")) {
                // 删除学生信息
                delete();
            } else if (choice.equals("2")) {
                System.out.println("已为您重新返回学生信息");
                browse();
            } else {
                System.out.println("输入错误，请重新输入");
                delete4();
            }
        }
    
        /**
         * 新增学生信息
         */
        public void add() {
            System.out.println("请输入学号");
            int id = key.nextInt();
            //检查学号是否与库中重复
            if (inspect(id)) {
                //若重复，重新输入
                System.out.println("学号重复，请重新输入");
                add();
            } else {
                //不重复，继续录入其他信息
                System.out.println("请输入姓名");
                String name = key.next();
                System.out.println("请输入专业");
                String major = key.next();
                System.out.println("请输入A课程成绩");
                double math_grade = key.nextDouble();
                System.out.println("请输入B课程成绩");
                double english_grade = key.nextDouble();
                System.out.println("请输入C课程成绩");
                double java_grade = key.nextDouble();
                System.out.println("请输入D课程成绩");
                double cpp_grade = key.nextDouble();
                double all_grade = math_grade + english_grade + java_grade + cpp_grade;
                int sort = studentDao.getDatabase().list.size() + 2;
                StudentNode student = new StudentNode(id, name, major, math_grade, english_grade,
                        java_grade, cpp_grade, all_grade, sort);
                studentDao.getDatabase().list.add(student);
                System.out.println("添加成功，已为您返回！");
                mean();
            }
        }
    
        /**
         * 检查学号是否与库中重复
         * 重复返回true，不重复返回false
         *
         */
        public boolean inspect(int id) {
            for (StudentNode s : studentDao.getDatabase().list) {
                if (s.getId() == id)
                    return true;
            }
            return false;
        }
    
        /**
         * 查找学生信息
         */
        public void find() {
            System.out.println("请选择查找的方式:");
            System.out.println("1.学生学号");
            System.out.println("2.学生姓名");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                    //学号查找
                    searchById();
                    break;
                case 2:
                    //姓名查找
                    searchByName();
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    find();
            }
    
        }
    
        /**
         * 使用学号查找学生信息
         *
         */
        public void searchById() {
            StudentNode student = null;
            System.out.println("请输入您要查找学生的学号");
            int id = key.nextInt();
            for (StudentNode s : studentDao.getDatabase().list) {
                if (s.getId() == id) {
                    student = s;
                }
            }
            if (student == null) {
                System.out.println("抱歉，没有找到该学生");
                nextBySearchById();
            } else {
                System.out.println("该学生信息如下：");
                System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "A课程成绩" + "\t" +
                        "B课程成绩" + "\t" + "C课程成绩" + "\t" + "D课程成绩" + "\t" + "总成绩" + "\t" + "排名");
                System.out.println(student.toString());
                nextBySearch(student);
            }
        }
    
        /**
         * 使用学号查找学生信息（以删除修改信息为目的）
         *
         */
        public StudentNode searchById(int id) {
            StudentNode student = null;
            for (StudentNode s : studentDao.getDatabase().list) {
                if (s.getId() == id) {
                    student = s;
                }
            }
            return student;
        }
    
        /**
         * 使用学号查找失败后的下一步操作
         */
        public void nextBySearchById() {
            System.out.println("请您选择接下来的选择:");
            System.out.println("1.重新输入学生学号");
            System.out.println("2.使用学生姓名查找");
            System.out.println("3.返回初始目录");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                    searchById();
                    break;
                case 2:
                    searchByName();
                    break;
                case 3:
                    mean();
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    nextBySearchById();
            }
        }
    
        /**
         * 查找成功后的下一步操作
         */
        public void nextBySearch(StudentNode student) {
            System.out.println("请输入接下来的选择");
            System.out.println("1.修改学生信息");
            System.out.println("2.删除学生信息");
            System.out.println("3.返回初始目录");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                    modification3(student);
                    break;
                case 2:
                    delete3(student);
                    break;
                case 3:
                    mean();
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    nextBySearchById();
            }
        }
    
        /**
         * 使用姓名查找学生信息
         *
         */
        public void searchByName() {
            StudentNode student = null;
            System.out.println("请输入您要查找学生的姓名:");
            String name = key.next();
            for (StudentNode s : studentDao.getDatabase().list) {
                if (s.getName().equals(name)) {
                    student = s;
                }
            }
            if (student == null) {
                System.out.println("抱歉，没有找到该学生!");
                nextBySearchByName();
            } else {
                System.out.println("该学生信息如下:");
                System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "A课程成绩" + "\t" +
                        "B课程成绩" + "\t" + "C课程成绩" + "\t" + "D课程成绩" + "\t" + "总成绩" + "\t" + "排名");
                System.out.println(student.toString());
                nextBySearch(student);
            }
        }
    
        /**
         * 使用姓名查找失败后的下一步操作
         */
        public void nextBySearchByName() {
            System.out.println("请您作接下来的选择:");
            System.out.println("1.重新输入学生姓名");
            System.out.println("2.使用学生学号查找");
            System.out.println("3.返回初始目录");
            int choice = key.nextInt();
            switch (choice) {
                case 1:
                    searchByName();
                    break;
                case 2:
                    searchById();
                    break;
                case 3:
                    mean();
                    break;
                default:
                    System.out.println("输入错误，请重新输入！");
                    nextBySearchById();
            }
        }
    
        /**
         * 保存学生信息
         */
        public void save() {
            Compare c = new Compare();
            Collections.sort(studentDao.getDatabase().list, c);
            studentDao.getDatabase().save();
            System.out.println("保存成功！");
            mean();
        }
    
        /**
         * 加载学生信息
         */
        public void load() {
            studentDao = new StudentDao(new Database());
            System.out.println("加载成功！");
            mean();
        }
        }

## 四、比较器工具类（tools包） ##

### 1.Compare类 ###

### 2.代码如下 ###

package tools;
    import pojo.StudentNode;
    
    import java.util.Comparator;
    
    public class Compare implements Comparator<StudentNode> {
    
        public int compare(StudentNode o1, StudentNode o2) {
            if (o1.getId() > o2.getId())
                return 1;
            else
                return -1;
        }
    }

## 五、数据库和文档交互类（data包） ##

### 1.Database类 ###

### 2.代码如下 ###

package data;
    import pojo.StudentNode;
    
    import java.util.ArrayList;
    
        public class Database {
            public ReaderWriter rw = new ReaderWriter();
            public ArrayList<StudentNode> list = new ArrayList<>();
    
            public Database() {
                ArrayList<String> list1 = rw.reader();
                for (String s : list1) {
                    String student[] = s.split(" ");
                    list.add(new StudentNode(Integer.parseInt(student[0]), student[1], student[2],
                            Double.parseDouble(student[3]), Double.parseDouble(student[4]),
                            Double.parseDouble(student[5]), Double.parseDouble(student[6]),
                            Double.parseDouble(student[7]), Integer.parseInt(student[8])));
                }
            }
    
            public Database(ArrayList<StudentNode> list) {
                this.list = list;
            }
    
            /**
             * 保存信息
             */
            public void save() {
                ArrayList<String> list1 = new ArrayList<>();
                for (StudentNode s : list) {
                    String s1 = s.getId() + " " + s.getName() + " " + s.getMajor() + " " + s.getMath_grade() + " " +
                            s.getEnglish_grade() + " " + s.getJava_grade() + " " + s.getCpp_grade() + " " +
                            s.getAll_grade() + " " + s.getSort();
                    list1.add(s1);
                }
                rw.writer(list1);
            }
        }

### 3.ReaderWriter类 ###

### 4.代码如下 ###

package data;
    import java.io.*;
    import java.util.ArrayList;
    
    public class ReaderWriter {
        public BufferedReader br;
        public BufferedWriter bw;
        public File file = new File("E:/javaText/javaOne/JavaSE/student.txt");
    
        public ReaderWriter() {
        }
    
        public ArrayList<String> reader() {
            ArrayList<String> list = new ArrayList<>();
            //创建字符缓冲输入流
            try {
                br = new BufferedReader(
                        new InputStreamReader(new FileInputStream(file)));
                String line = null;
                while ((line = br.readLine()) != null) {
                    list.add(line);
                }
                br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return list;
        }
    
        public boolean writer(ArrayList<String> list) {
            try {
                bw = new BufferedWriter(
                        new OutputStreamWriter(new FileOutputStream(file)));
                for (String s : list) {
                    bw.write(s);
                    bw.newLine();
                }
                bw.close();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    }

## 六、排序方法类（sort包） ##

### 1.BidirectionalBubbleSort类（双向冒泡排序） ###

### 2.代码如下 ###

package sort;
    import pojo.StudentNode;
    
    import java.util.ArrayList;
    public class BidirectionalBubbleSort {
        /**
         * 根据总成绩排序
         *
         */
        public void sortByAll(ArrayList<StudentNode> list) {
            boolean needNextPass = true;
            for (int i = 0, j; i < list.size() / 2 && needNextPass; i++) {
                needNextPass = false;
                // 正向排序
                for (j = i; j < list.size() - 1 - i; j++) {
                    if (list.get(j).getAll_grade() < list.get(j + 1).getAll_grade()) {
                        StudentNode student = list.get(j);
                        list.set(j, list.get(j + 1));
                        list.set(j + 1, student);
                        needNextPass = true;
                    }
                }
                // 反向排序
                for (--j; j > i; j--) {
                    if (list.get(j).getAll_grade() > list.get(j - 1).getAll_grade()) {
                        StudentNode student = list.get(j);
                        list.set(j, list.get(j - 1));
                        list.set(j - 1, student);
                        needNextPass = true;
                    }
                }
            }
            for (StudentNode s : list) {
                s.setSort(list.indexOf(s) + 1);
            }
        }
    
    }

### 3.ShellSort类（希尔排序） ###

### 4.代码如下 ###

package sort;
    import pojo.StudentNode;
    
    import java.util.ArrayList;
    
    public class ShellSort {
        public void sortByAll(ArrayList<StudentNode> list) {
            for (int gap = (int) Math.floor((list.size()) / 2); gap > 0; gap = (int) Math.floor(gap / 2)) {
                for (int i = gap; i < list.size(); i++) {
                    int j = i;
                    double value = list.get(i).getAll_grade();
                    StudentNode student = list.get(i);
                    while (j - gap >= 0 && value > list.get(j - gap).getAll_grade()) {
                        list.set(j, (list.get(j - gap)));
                        j = j - gap;
                    }
                    list.set(j, student);
                }
            }
            for (StudentNode s : list) {
                s.setSort(list.indexOf(s) + 1);
            }
        }
    }

### 5.QuickSort类（快速排序） ###

### 6.代码如下 ###

package sort;
    import pojo.StudentNode;
    
    import java.util.ArrayList;
    
    public class QuickSort {
    
        public void sortByAll(ArrayList<StudentNode> list, int low, int high) {
            int i, j;
            StudentNode student;
            double temp;
            if (low > high) {
                return;
            }
            i = low;
            j = high;
            //temp就是基准位
            temp = list.get(low).getAll_grade();
            while (i < j) {
                //先看右边，依次往左递减
                while (temp >= list.get(j).getAll_grade() && i < j) {
                    j--;
                }
                //再看左边，依次往右递增
                while (temp <= list.get(i).getAll_grade() && i < j) {
                    i++;
                }
                //如果满足条件则交换
                if (i < j) {
                    student = list.get(j);
                    list.set(j, list.get(i));
                    list.set(i, student);
                }
    
            }
            //最后将基准为与i和j相等位置的数字交换
            student = list.get(low);
            list.set(low, list.get(i));
            list.set(i, student);
            //递归调用左半数组
            sortByAll(list, low, j - 1);
            //递归调用右半数组
            sortByAll(list, j + 1, high);
            for (StudentNode s : list) {
                s.setSort(list.indexOf(s) + 1);
            }
        }
    }

### 7.HeapSort类（堆排序） ###

### 8.代码如下 ###

package sort;
    import pojo.StudentNode;
    
    import java.util.ArrayList;
    
    public class HeapSort {
        public void sortByAll(ArrayList<StudentNode> list) {
            //一次调整，最大值到了根节点
            for (int i = (list.size() - 1 - 1) / 2; i >= 0; i--) {//i相当于start
                adjust(list, i, list.size() - 1);
            }
            //最后一个值与根节点交换
            StudentNode student = new StudentNode();
            for (int j = 0; j < list.size() - 1; j++) {
                student = list.get(0);
                list.set(0, list.get(list.size() - 1 - j));
                list.set(list.size() - 1 - j, student);
                adjust(list, 0, list.size() - 1 - 1 - j);//调整最大的树
            }
            for (StudentNode s : list) {
                s.setSort(list.indexOf(s) + 1);
            }
        }
    
        public static void adjust(ArrayList<StudentNode> list, int start, int end) {
    
            StudentNode student = list.get(start);
            //一次调整过程
            for (int i = 2 * start + 1; i <= end; i = 2 * i + 1) {
                //找到左右孩子的最大值
                if (i < end && list.get(i).getAll_grade() > list.get(i + 1).getAll_grade()) {
                    i++;  //最大值下标
                }
                if (list.get(i).getAll_grade() < student.getAll_grade()) {
                    list.set(start, list.get(i));    //设置第start个位置元素的值
                    start = i;
                }
                if (list.get(i).getAll_grade() > student.getAll_grade()) {
                    break;
                }
            }
            list.set(start, student);
        }
    }

## 七、主类（main包） ##

### 1.main类 ###

### 2.代码如下 ###

package main;
    import service.StudentService;
    import data.Database;
    
    /**
     * 创建其他类的对象，调用这些对象的方法。
     *
     */
    public class Main {
        public static void main(String[] args) {
            Database database = new Database();
            StudentService studentService = new StudentService(database);
            studentService.start();
        }
    
    }

## 八、学生信息储存文件（student.txt） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70]

## 九、学生成绩档案系统成果展示 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210309155418665.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210309153603873.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210309153754416.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210309153917525.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210309154847548.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2021030915492966.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210309155008716.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210309155045870.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2021030915513215.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4MTcwMjY1,size_16,color_FFFFFF,t_70