《数据结构课程实践》_01_学生成绩档案管理系统_实现

最新推荐文章于 2021-07-10 10:03:32 发布

Laxsilence

最新推荐文章于 2021-07-10 10:03:32 发布

阅读量345

点赞数 1

分类专栏：数据结构课程实践

本文链接：https://blog.csdn.net/jsinszjjs/article/details/114292699

版权

数据结构课程实践专栏收录该内容

6 篇文章 0 订阅

订阅专栏

01_学生成绩档案管理系统_实现

一、实验题目
二、编程语言以及开发环境
三、源代码
四、运行结果
五、实验小结

一、实验题目

学生信息录入，信息包括学号、姓名、专业、四门课的成绩、总分、名次；
系统可对学生信息浏览，增加，删除和修改；
按学生成绩确定名次以及信息输出，双向冒泡排序、希尔排序、快速排序、堆排序；
要求可对学生信息查询，根据学号或姓名进行查找；
信息修改仅可修改四门课程的成绩
文件存取学生信息

二、编程语言以及开发环境

1. 编程语言：
选择Java，因为在上学期 project 01中对Java进行了一次提高，现在习惯用Java来编写

2. 开发环境：
选择IntelliJ IDEA，使用起来更加方便

三、源代码

1.学生类

package com.Student;

/**
 * 学生类，包含各种属性
 */
public class Student {
    //学号
    private int Id;
    //姓名
    private String username;
    //专业
    private String major;
    //课程1的成绩
    private double score1;
    //课程2的成绩
    private double score2;
    //课程3的成绩
    private double score3;
    //课程4的成绩
    private double score4;
    //总分
    private double scoreAll;
    //排名
    private int rank;

    //含参数
    public Student(int id, String username, String major, double score1, double score2, double score3, double score4) {
        Id = id;
        this.username = username;
        this.major = major;
        this.score1 = score1;
        this.score2 = score2;
        this.score3 = score3;
        this.score4 = score4;
        this.scoreAll = score1 + score2 + score3 + score4 ;
    }

    public int getId() {
        return Id;
    }

    public String getUsername() {
        return username;
    }

    public String getMajor() {
        return major;
    }

    public double getScore1() {
        return score1;
    }

    public double getScore2() {
        return score2;
    }

    public double getScore3() {
        return score3;
    }

    public double getScore4() {
        return score4;
    }

    public double getScoreAll() {
        return scoreAll;
    }

    public int getRank() {
        return rank;
    }

    public void setId(int id) {
        Id = id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public void setScore1(double score1) {
        this.score1 = score1;
    }

    public void setScore2(double score2) {
        this.score2 = score2;
    }

    public void setScore3(double score3) {
        this.score3 = score3;
    }

    public void setScore4(double score4) {
        this.score4 = score4;
    }

    public void setScoreAll(double scoreAll) {
        this.scoreAll = scoreAll;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }
}

2.自定义数据库类

package com.data;

import com.Student.Student;

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

/**
 * 学生信息，由自己初始化类
 */
public class studentData {
    //私有类型链表
    private List<Student> studentList = new ArrayList<>();

    /*
    构造参数，初始化学生数据
     */
    public studentData() {

        Student student1 = new Student(1, "张三", "软件工程", 78.2, 63, 91, 68);
        Student student2 = new Student(2, "李四", "信息安全", 68, 88, 54, 93);
        Student student3 = new Student(3, "王五", "软件工程", 87, 78, 62, 88);
        Student student4 = new Student(4, "赵六", "物联网", 92, 69, 79, 77);
        Student student5 = new Student(5, "陈七", "信息安全", 54, 83, 86, 96);
        //使用Arrays.asList，可以直接导入多个对象，不用一直add,但是该方法后边不允许使用add方法
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        studentList.add(student5);
    }

    public List<Student> getStudentList() {
        return studentList;
    }

    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
    
}

3.数据操作类

package com.studentDao;

import com.Student.Student;
import com.data.studentData;

import java.util.List;


public class studentDao {

    //链表类型元素
    private studentData studentData;

    /*/
    构造函数
     */

    public studentDao(studentData studentData) {
        this.studentData = studentData;
    }

    /**
     * 现有学生信息展示
     */
    public void printLink(){
        System.out.println();
        System.out.println("*************************************已经拥有的学生信息如下***************************************");
        System.out.println("______________________________________________________________________________________________");
        System.out.println("学号\t\t"+"姓名\t\t"+"专业\t\t\t"+"成绩1\t\t"+"成绩2\t\t"+"成绩3\t\t"+"成绩4\t\t"+"总分\t\t\t");
        System.out.println("***********************************************************************************************");
        for (int i = 0; i<studentData.getStudentList().size();i++){
            int count = i;
            printStudentTwo(count);
        }
    }



    /**
     * 得到新的学号,采用当前时间值
     * @return
     */
    /*public int newId(){
        int newId = (int) System.currentTimeMillis();
        newId = -newId;
        return newId;
    }
    */


    /**
     * 添加学生信息
     * @param student
     */
    public void addStudentMassage(Student student){
        studentData.getStudentList().add(student);
    }

    /**
     * 删除学生信息
     * @param delId
     */
    public void delStudent(int delId){
        for (int i=0;i<studentData.getStudentList().size();i++){
            if (studentData.getStudentList().get(i).getId()== delId){
                studentData.getStudentList().remove(i);
                break;
            }
        }
    }

    /**
     * 修改学生信息
     * @param modID
     */
    public void modStudent(int modID,double newScore1,double newScore2,double newScore3,double newScore4){
        for (int i=0;i<studentData.getStudentList().size();i++){
            if (studentData.getStudentList().get(i).getId() == modID){
                double allScore = newScore1+newScore2+newScore3+newScore4;
                studentData.getStudentList().get(i).setScore1(newScore1);
                studentData.getStudentList().get(i).setScore2(newScore2);
                studentData.getStudentList().get(i).setScore3(newScore3);
                studentData.getStudentList().get(i).setScore4(newScore4);
                studentData.getStudentList().get(i).setScoreAll(allScore);
                break;
            }
        }

    }

    /**
     * 通过姓名搜索
     * @param SerName
     */
    public void searchStudentByName(String SerName){
        for (int i=0;i<studentData.getStudentList().size();i++){
            if (studentData.getStudentList().get(i).getUsername().equals(SerName)){
                int count = i;
                printStudent();
                printStudentTwo(count);
            }
        }
    }


    /**
     * 输出显示格式
     * @param
     */
    public void printStudent(){
                System.out.println("学号\t\t"+"姓名\t\t"+"专业\t\t\t"+"成绩1\t\t"+"成绩2\t\t"+"成绩3\t\t"+"成绩4\t\t"+"总分\t\t\t");
                System.out.println("***********************************************************************************************");
    }

    /**
     * 输出显示结果
     * @param count
     */
    public void printStudentTwo(int count){
        System.out.println(studentData.getStudentList().get(count).getId()+"\t\t"+studentData.getStudentList().get(count).getUsername()+"\t\t"+studentData.getStudentList().get(count).getMajor()+"\t\t"+studentData.getStudentList().get(count).getScore1()+"\t\t"+studentData.getStudentList().get(count).getScore2()+"\t\t"+studentData.getStudentList().get(count).getScore3()+"\t\t"+studentData.getStudentList().get(count).getScore4()+"\t\t"+studentData.getStudentList().get(count).getScoreAll()+"\t\t");
    }


    /**
     * 通过学号搜索
     * @param SerID
     */
    public void searchStudentByID(int SerID){
        for (int i=0;i<studentData.getStudentList().size();i++){
            if (studentData.getStudentList().get(i).getId()==SerID){
                int thisCount = i;
                printStudent();
                printStudentTwo(thisCount);
            }
        }
    }

    /**
     * 排名赋值并打印
     * @param studentList
     */
    public void showPlace(List<Student> studentList){
        System.out.println("学号\t\t"+"姓名\t\t"+"专业\t\t\t"+"总分\t\t\t"+"名次\t\t\t");
        System.out.println("********************************************");
        for(int i=0;i<studentList.size();i++){
            studentList.get(i).setRank(i+1);
        }
        int i=1;
        for(Student each:studentList){
            System.out.println(each.getId()+"\t\t"+each.getUsername()+"\t\t"+each.getMajor()+"\t\t"+each.getScoreAll()+"\t\t"+each.getRank());
            i++;
        }
    }

    /**
     * 双向冒泡排序
     * @param studentList
     * @return
     */
    public List<Student> doubleBubbleSort(List<Student> studentList){
        List<Student> list = studentList;
        Student student = null;
        int left=0,right = studentList.size()-1;
        while(left<right)
        {
            for(int i=left+1;i<=right;i++){
                if(list.get(left).getScoreAll()<list.get(i).getScoreAll()){
                    student = list.get(i);
                    list.set(i,list.get(left));
                    list.set(left,student);
                }
            }
            left++;
            for(int i=right-1;i>=left;i--){
                if(list.get(right).getScoreAll()>list.get(i).getScoreAll()){
                    student=list.get(i);
                    list.set(i,list.get(right));
                    list.set(right,student);
                }
            }
            right--;
        }
        return list;
    }

    /**
     * 希尔排序
     * @param studentList
     * @return
     */
    public List<Student> shellSort(List<Student> studentList){
        List<Student> list = studentList;
        Student student = null;
        int j;
        for (int gap = list.size() / 2; gap >  0; gap /= 2) {
            for (int i = gap; i < list.size(); i++) {
                student=list.get(i);
                double tmp=student.getScoreAll();
                for (j = i; j >= gap && tmp>list.get(j-gap).getScoreAll(); j -= gap) {
                    list.set(j,list.get(j-gap));
                }
                list.set(j,student);
            }
        }
        return list;
    }

    /**
     * 快速排序
     * @param studentList
     * @return
     */
    public List<Student> quickSort(List<Student> studentList){
        List<Student> list=studentList;
        quickSort1(list,0,list.size()-1);
        return list;
    }
    public void quickSort1(List<Student> studentList,int left,int right){
        if(left<right){
            int i=left,j=right;
            Student student=studentList.get(left);
            double x=student.getScoreAll();
            while(i<j){
                while((i<j)&&(studentList.get(j).getScoreAll()<x)){
                    j--;
                }
                if(i<j){
                    studentList.set(i,studentList.get(j));
                    i++;
                }
                while((i<j)&&(studentList.get(i).getScoreAll()>x)){
                    i++;
                }
                if(i<j){
                    studentList.set(j,studentList.get(i));
                    j--;
                }
            }
            studentList.set(i,student);
            quickSort1(studentList,left,i-1);
            quickSort1(studentList,i+1,right);
        }
    }

    /**
     * 堆排序
     * @param studentList
     * @return
     */
    public List<Student> heapSort(List<Student> studentList){
        List<Student> list=studentList;
        int len = list.size();

        buildMaxHeap(list, len);

        for (int i = len - 1; i > 0; i--) {
            swap(list, 0, i);
            len--;
            heapify(list, 0, len);
        }
        return list;
    }

    private void buildMaxHeap(List<Student> studentList, int len) {
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(studentList, i, len);
        }
    }
    private void heapify(List<Student> studentList, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < len && studentList.get(left).getScoreAll() < studentList.get(largest).getScoreAll()) {
            largest = left;
        }

        if (right < len && studentList.get(right).getScoreAll() < studentList.get(largest).getScoreAll()) {
            largest = right;
        }

        if (largest != i) {
            swap(studentList, i, largest);
            heapify(studentList, largest, len);
        }
    }

    private void swap(List<Student> studentList, int i, int j) {
        Student student=studentList.get(i);
        studentList.set(i,studentList.get(j));
        studentList.set(j,student);
    }
}

4.总服务类

package com.serves;

import com.Student.Student;
import com.data.studentData;
import com.studentDao.studentDao;

import java.util.List;
import java.util.Scanner;

public class serves {

    Scanner scanner = new Scanner(System.in);

    //实例化Dao
    studentData data ;
    studentDao studentDao ;
    /*
    构造函数
     */
    public serves(studentData studentData) {
        this.data = studentData;
        studentDao=new studentDao(data);
    }


    /**
     * 系统开关
     */
    public void begin(){
        //起始界面,调用Dao中打印显示
        studentDao.printLink();

        System.out.println();
        System.out.println("_________________请输入你的选项__________________");
        System.out.println("1. 学生信息增加");
        System.out.println("2. 学生信息删除");
        System.out.println("3. 学生信息修改");
        System.out.println("4. 学生信息排序");
        System.out.println("5. 学生信息查询");
        System.out.println("6. 学生信息打印");
        System.out.println("7. 退出系统");
        int choice1 = scanner.nextInt();

        //进行功能判断
        switch (choice1){
            case 1:
                addStudent();
                break;
            case 2:
                deleteStudent();
                break;
            case 3:
                modifyStudent();
                break;
            case 4:
                sortStudent();
                break;
            case 5:
                System.out.println("请选择查询方式：1.按姓名查询  2.按学号查询");
                int search = scanner.nextInt();
                switch (search){
                    case 1:
                        searchStudentByName();
                        break;
                    case 2:
                        searchStudentByID();
                        break;
                        default:
                            System.out.println("非法输入，已经返回主菜单：");
                            begin();
                }

                break;
            case 6:
                studentDao.printLink();
                System.out.println("学生信息成绩已经打印");
                System.out.println("按5返回主菜单");
                int count5 = scanner.nextInt();
                if (count5==5){
                    begin();
                }else{
                    System.out.println("非法输入，已自动返回主菜单");
                    begin();
                }
                break;
            case 7:
                System.out.println("你已经退出系统！");
                break;
            default:
                System.out.println("非法输入，请重新输入：");
                System.out.println("###########################################################################################");
                    begin();
        }


    }

    /**
     * 新增学生信息
     */
    public void addStudent(){
        System.out.println("请输入学号：");
        int newId = scanner.nextInt();
        System.out.println("请输入学生姓名：");
        String newName = scanner.next();
        System.out.println("请输入专业：");
        String newMajor = scanner.next();
        System.out.println("请输入成绩1：");
        double newScore1 = scanner.nextDouble();
        System.out.println("请输入成绩2：");
        double newScore2 = scanner.nextDouble();
        System.out.println("请输入成绩3：");
        double newScore3 = scanner.nextDouble();
        System.out.println("请输入成绩4：");
        double newScore4 = scanner.nextDouble();

        Student newStudent = new Student(newId,newName,newMajor,newScore1,newScore2,newScore3,newScore4);
        studentDao.addStudentMassage(newStudent);
        System.out.println("学生信息添加成功！输入0返回主菜单");
        int count = scanner.nextInt();
        if (count==0){
            begin();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }

    /**
     * 删除学生信息
     */
    public void deleteStudent(){
        System.out.println("请输入你要删除的学生的学号:");
        int delId = scanner.nextInt();
        studentDao.delStudent(delId);
        System.out.println("你已经成功删除该学生的信息！按1返回主菜单");
        int count2 = scanner.nextInt();
        if (count2==1){
            begin();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }

    /**
     * 修改学生信息
     */
    public void modifyStudent(){
        System.out.println("只能修改课程成绩，请输入你要修改的学生的学号:");
        int modId = scanner.nextInt();
        System.out.println("请输入新的成绩1：");
        double newScore1 = scanner.nextDouble();
        System.out.println("请输入新的成绩2：");
        double newScore2 = scanner.nextDouble();
        System.out.println("请输入新的成绩3：");
        double newScore3 = scanner.nextDouble();
        System.out.println("请输入新的成绩4：");
        double newScore4 = scanner.nextDouble();
        studentDao.modStudent(modId,newScore1,newScore2,newScore3,newScore4);
        System.out.println("你已经成功修改该学生的信息！按2返回主菜单");
        int count3 = scanner.nextInt();
        if (count3==2){
            begin();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }

    /**
     * 通过学生姓名查询学生信息
     */
    public void searchStudentByName(){
        System.out.println("请输入你要查询的学生的姓名：");
        String SerName = scanner.next();
        studentDao.searchStudentByName(SerName);
        System.out.println("按3返回主菜单");
        int count4 = scanner.nextInt();
        if (count4==3){
            begin();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }

    /**
     * 通过学号查询
     */
    public void searchStudentByID(){
        System.out.println("请输入你要查询的学生的学号：");
        int  SerId = scanner.nextInt();
        studentDao.searchStudentByID(SerId);
        System.out.println("按4返回主菜单");
        int count5 = scanner.nextInt();
        if (count5==4){
            begin();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }


    /**
     * 排序总方法
     */
    public void sortStudent(){
        List<Student> list = null;
        System.out.println("请选择排序方式：");
        System.out.println("1.双向冒泡排序");
        System.out.println("2.希尔排序");
        System.out.println("3.快速排序");
        System.out.println("4.堆排序");
        System.out.println("按0返回主菜单：");
        int choice2 = scanner.nextInt();
        switch (choice2){
            case 0:
                begin();
                break;
            case 1:
                list=studentDao.doubleBubbleSort(data.getStudentList());
                studentDao.showPlace(list);
                sortOutput();
                break;
            case 2:
                list=studentDao.shellSort(data.getStudentList());
                studentDao.showPlace(list);
                sortOutput();
                break;
            case 3:
                list=studentDao.quickSort(data.getStudentList());
                studentDao.showPlace(list);
                sortOutput();
                break;
            case 4:
                list=studentDao.heapSort(data.getStudentList());
                studentDao.showPlace(list);
                sortOutput();
                break;
                default:
                    System.out.println("非法输入，请重新选择：");
                    sortStudent();
        }
    }
     /**
     * 排序成功
     */
    public void sortOutput(){
        System.out.println("排序成功，按0返回上一菜单：");
        int dearLiu = scanner.nextInt();
        if (dearLiu==0){
            sortStudent();
        }else{
            System.out.println("非法输入，已自动返回主菜单");
            begin();
        }
    }
}

5. main类

import com.data.studentData;
import com.serves.serves;
import com.studentDao.studentDao;

public class main {
    public static void main(String[] args) {
       //实例化
        studentData data = new studentData();
        studentDao studentDao = new studentDao(data);
        serves serves = new serves(data);
        serves.begin();
    }
}

四、运行结果

1. 初始界面：

2. 学生信息增加：
学生信息增加01
学生信息增加02
3. 学生信息修改：
学生信息修改01
学生信息修改02
4. 学生信息查询：

按姓名查询
按学号查询

5. 学生信息排序：

双向冒泡排序
希尔排序
快速排序
堆排序

6. 学生信息删除：

7. 学生信息打印：

学生信息打印

五、实验小结

在本次实验中，有一些细节的地方没有注意到，比如说，在修改学习成绩后，发现因为成绩不是按照参数传递进去的，导致成绩的总分数没有发生修改，所以在修改的方法中又特地添加了计算修改后的总分，使得代码有些麻烦。
对于排序方法有些陌生，四个排序方法都有查询资料，同时借鉴别人的部分代码才写出来，确实是自己学习的时候没有掌握透彻，在接下来会把这四个排序算法详细的查看理解一遍。
整个假期没有进行过Java的编写，发现自己的速度慢了很多，也明白了所有的东西都应该是熟能生巧，在接下来的日子里，会多联系，养成好习惯。

今日喜欢的句子：

在做决定之前，你要仔细聆听内心的声音。很多时候其实雨并不大，只是风搞得让人紧张。

@刘英俊