学生信息管理系统

最新推荐文章于 2022-10-05 16:51:48 发布

暮榆

最新推荐文章于 2022-10-05 16:51:48 发布

阅读量330

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_51293027/article/details/114683126

版权

Students类

简介：该类用于学生用户的信息的初始化以及含有一个遍历输出学生集合的ShowAll()函数。

public class Students {
	private String name;
	private int studentsId;
	private String subject;
	private double score1;
	private double score2;
	private double score3;
	private double score4;
	private double Allscore;
	private int rank;
	public Students(int studentsId,String name,String subject,double score1,double score2,double score3,double score4) {
		this.studentsId=studentsId;
		this.name=name;
		this.subject=subject;
		this.score1=score1;
		this.score2=score2;
		this.score3=score3;
		this.score4=score4;
		this.Allscore=this.score1+this.score2+this.score3+this.score4;
		this.rank=0;
	}
	public Students(String studentsId,String name,String subject,String score1,String score2,String score3,String score4) {
		this.studentsId=Integer.parseInt(studentsId);
		this.subject=subject;
		this.name=name;
		this.subject=subject;
		this.score1=Double.parseDouble(score1);
		this.score2=Double.parseDouble(score2);
		this.score3=Double.parseDouble(score3);
		this.score4=Double.parseDouble(score4);
		this.Allscore=this.score1+this.score2+this.score3+this.score4;
		this.rank=0;
	}
	public Students(String studentsId,String name,String subject,String score1,String score2,String score3,String score4,String Allscore,String rank) {
		this.studentsId=Integer.parseInt(studentsId);
		this.subject=subject;
		this.name=name;
		this.subject=subject;
		this.score1=Double.parseDouble(score1);
		this.score2=Double.parseDouble(score2);
		this.score3=Double.parseDouble(score3);
		this.score4=Double.parseDouble(score4);
		this.Allscore=this.score1+this.score2+this.score3+this.score4;
		this.rank=Integer.parseInt(rank);
	}
	public int studentsId() {
		return studentsId;
	}
	public String name() {
		return name;
	}
	public String subject() {
		return subject;
	}
	public double score1() {
		return score1;
	}
	public double score2() {
		return score2;
	}
	public double score3() {
		return score3;
	}
	public double score4() {
		return score4;
	}
	public int getstudentsId() {
		// TODO 自动生成的方法存根
		return studentsId;
	}
	public void setstudentsId(int studentsId) {
		// TODO 自动生成的方法存根
		this.studentsId=studentsId;
	}
	public String getname() {
		// TODO 自动生成的方法存根
		return name;
	}
	public void setname(String name) {
		// TODO 自动生成的方法存根
		this.name=name;
	}
	public String getsubject() {
		// TODO 自动生成的方法存根
		return subject;
	}
	public void getsubject(String subject) {
		// TODO 自动生成的方法存根
		this.subject=subject;
	}
	public double getscore1() {
		// TODO 自动生成的方法存根
		return score1;
	}
	public void setscore1(double score1) {
		// TODO 自动生成的方法存根
		this.score1=score1;
	}
	public double getscore2() {
		// TODO 自动生成的方法存根
		return score2;
	}
	public void setscore2(double score2) {
		// TODO 自动生成的方法存根
		this.score2=score2;
	}
	public double getscore3() {
		// TODO 自动生成的方法存根
		return score3;
	}
	public void setscore3(double score3) {
		// TODO 自动生成的方法存根
		this.score3=score3;
	}
	public double getscore4() {
		// TODO 自动生成的方法存根
		return score4;
	}
	public void setscore4(double score4) {
		// TODO 自动生成的方法存根
		this.score4=score4;
	}
	 public void setScore(double score1,double score2,double score3,double score4) {
	        this.score1=score1;
	        this.score2=score2;
	        this.score3=score3;
	        this.score4=score4;
	    }
	 public double getAllscore() {
		 return Allscore;
	 }
	public String getAllInfo() {
		return new String(studentsId+","+name+","+subject+","+score1+","+score2+","+score3+","+score4+","+Allscore+","+rank);
	}
	public void setRank(int i) {
		this.rank=i;
	}
	public void setAllscore(double i) {
		this.Allscore=i;
	}
	public double getAllscore(double i) {
		return Allscore;
	}
	public double getAllscore(int i) {
		// TODO 自动生成的方法存根
		return Allscore;
	}
	 public void showAll(){
	        System.out.println(studentsId+"  "+name+"   "+subject+"  "+score1+"  "+score2+"  "+ score3+"  "+score4+"  "+Allscore+"  "+rank);
	    }
	public int getRank() {
		// TODO 自动生成的方法存根
		return rank;
	}
}

StudentsDao类

简介：该类主要包含了4种排序算法、学生信息的增删改、查找函数以及学生排名名次的处理。

public class StudentsDao {
	private Text database;
    public StudentsDao(Text database) {
        this.database = database;
        sortStudent();
        database.update();
    }

学号查询：xhshow()

/**
 * 学生信息详细显示，通过学号号查询
 * 输入将要查询的学生学号，通过for循环遍历学生链表，当查找到相同学号时，打印输入该学生的信息；若未找到，系统将提示用户该系统中不存在此学生。
 */
public void xhshow(int num){
	 List<Students>list=database.getstudents();
     for(int i=0;i<list.size();i++){
         int count=list.get(i).studentsId();
         if(count==num){
        	 Students students = (Students) list.get(i);
        	 System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "高数"+"\t"+"大物"+"\t"+"英语"+"\t"+"毛概"+"\t"+"总分"+"\t"+"名次");
             System.out.println(list.get(i).getstudentsId() + "\t" + list.get(i).getname() + "\t" + list.get(i).getsubject() + "\t" + list.get(i).getscore1()+"\t"+list.get(i).getscore2()+"\t"+list.get(i).getscore3()+"\t"+list.get(i).getscore4()+"\t"+(list.get(i).getscore1()+list.get(i).getscore2()+list.get(i).getscore3()+list.get(i).getscore4())+"\t"+list.get(i).getRank());
         }
     }
}

姓名查找：xmshow()

 /**
 * 学生信息详细显示，通过姓名号查询
 * 用户输入将要查找的学生姓名，系统通过for循环遍历学生链表，通过.equals()函数查找到相同姓名的学生，打印输出该学生信息（如果系统中存在相同姓名的学生，系统将依次输出这些学生的信息）；若未找到，系统将提示用户该系统中不存在此学生。
 */
public void xmshow(String name){
	List<Students>list=database.getstudents();
    for(int i=0;i<list.size();i++){
        String Name=list.get(i).getname();
        if(Name.equals(name)){
       	 Students students = (Students) list.get(i);
       	 System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "高数"+"\t"+"大物"+"\t"+"英语"+"\t"+"毛概"+"\t"+"总分"+"\t"+"名次");
            System.out.println(list.get(i).getstudentsId() + "\t" + list.get(i).getname() + "\t" + list.get(i).getsubject() + "\t" + list.get(i).getscore1()+"\t"+list.get(i).getscore2()+"\t"+list.get(i).getscore3()+"\t"+list.get(i).getscore4()+"\t"+(list.get(i).getscore1()+list.get(i).getscore2()+list.get(i).getscore3()+list.get(i).getscore4())+"\t"+list.get(i).getRank());
        }
    }
}

名次处理：sortStudent()

/**
 * 计算学生排名
 * 对于已经排好序的学生链表，我们通过用count记录某学生在链表中的位置，用num记录该学生前一名的学生的名次。每次记录一位学生的名次时，我们将他的总分同前一名总分进行比较，如果分数相同，则该学生的名次用num赋值，即名次与前一位名次相同；如果分数低于前一名，则用count赋值，即该学生在链表中的位置，也就相对应他的名次。
 */
public void sortStudent(){
    List <Students>list= database.getstudents();
     int count=1;//记第几个数
     int num=0;//记前一位的排名
    for(int i=0;i< list.size();i++){
    	if(i>0) {
    		if(list.get(i).getAllscore(i)==list.get(i-1).getAllscore()) {
    			list.get(i).setRank(num);
    			count++;
    		}else {
    			list.get(i).setRank(count);
    			num=count;
                count++;
    		}
    	}else {
            list.get(i).setRank(count);
            num=count;
            count++;
    	}
    }
    database.update();//文本的更新
}

删除学生信息：Student()

 /*
 * 删除学生信息，通过学号查找，然后删除
 * 用户输入将要删除的学生的学号，系统通过遍历链表查找到相应的学生，将他的信息从链表中移除。然后再通过快速排序对链表重新排序，最后更新文本。若未找到，系统将提示用户该系统中不存在此学生。
 */
public void delete(int studentsId){
    for (Students students : database.getstudents()) {
        if (students.getstudentsId()==studentsId){
            database.getstudents().remove(students);
            break;
        }
    }
}

新增学生信息：insert()

/*
 * 新增学生信息
 * @param students
 * 用户输入将要新增的学生信息，通过链表的.add()功能实现新增。
 * 注：新增学生信息时，系统将对其学号在原链表进行匹配，若匹配成功（即该学号已存在），系统将提示错误，即新增失败（具体过程在StudentsSystem类新增学生信息中）。
 */
public void insert(Students students){
    database.getstudents().add(students);
}

修改学生信息: modify()

/*
 * 修改学生分数
 * @param students
 * @param score1,score2,score3,score4
 * 通过用户输入将要修改的学生学号以及4门科目的分数，实现修改。
 * 修改时，首先系统将会对输入的学号在学生链表中进行匹配。若匹配成功，则成功修改。若匹配失败，即该学生不存在。
 */
public void modify(int studentsId,double score1,double score2,double score3,double score4){
    for (Students students : database.getstudents()) {
        if (students.getstudentsId()==studentsId){
            students.setScore(score1,score2,score3,score4);
            students.setAllscore((score1+score2+score3+score4));
            System.out.println("修改后学生信息：");
            System.out.println(students.getstudentsId()+"\t"+students.getname()+"\t"+students.getsubject()+"\t"+students.getscore1()+"\t"+students.getscore2()+"\t"+students.getscore3()+"\t"+students.getscore4());
            break;
        }
    }
}

学生信息显示：print()

 /*
 * 通过for循环遍历整个链表，打印输出所有学生信息
 */
public  void print(){
	sortStudent();
    List<Students>list=database.getstudents();
    System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "高数"+"\t"+"大物"+"\t"+"英语"+"\t"+"毛概"+"\t"+"总分"+"\t"+"名次");
    for (int i = 0; i < list.size(); i++) {
        Students students = (Students) list.get(i);
        System.out.println(students.getstudentsId() + "\t" + students.getname() + "\t" + students.getsubject() + "\t" + students.getscore1()+"\t"+students.getscore2()+"\t"+students.getscore3()+"\t"+students.getscore4()+"\t"+(students.getscore1()+students.getscore2()+students.getscore3()+students.getscore4())+"\t"+students.getRank());
    }
}

双向冒牌排序：ShakerSort()

/*
 * 双向冒泡排序:左右扫描，两两比较交换位置
 * front指向头，behin指向尾。
 * 从第一个数开始向后进行冒泡，若后一个数比前一个小，则交换位置，最后使最后一个数为最大值。
 * 然后从最后一个数向前进行冒泡，若前一个数比后一个数大，则交换位置，最后使第一个数为最小值。
 * 进行完一趟双向冒泡后，第一个数和最后一个数位置以及确定好了，front++，behind--。front指向第二个数，behind指向倒数第二个数，再次进行冒泡排序。
 * 重复上述步骤，直到front>behind时停止，这时序列已经被排好了。
 */
public void ShakerSort(List<Students>list) {
	 int front=0,behind = list.size()-1;
     while(front<behind){
         //左侧扫描
         for(int j = front+1; j <= behind; j++) {
             if(list.get(front).getAllscore()<list.get(j).getAllscore()) {
                 Students temp=list.get(front);
                 list.set(front,list.get(j));
                 list.set(j,temp);
             }
         }
         front++;
         if(front>=behind){
             break;
         }
         //右侧扫描
         for(int j = behind-1; j >= front; j--) {
             if(list.get(behind).getAllscore()>list.get(j).getAllscore()) {
                 Students temp=list.get(behind);
                 list.set(behind,list.get(j));
                 list.set(j,temp);
             }
         }
         behind--;
     }
}

希尔排序：ShellsSort()

/*
 *  希尔排序:取间隔分组，然后直接插入排序
 * 希尔排序是对直接插入排序的改良排序
 * 我们首先取间隔（一般间隔为被排序数长度的一半），然后以该间隔进行分组(如：1，2，3，4，5，6，7   我们间隔为3，则1，4，7为一组；2，5为一组，3，6为一组）。分组完成后，在组内进行直接插入排序。排完序后，我们在取间隔为上一次间隔的一半，再分组排序。直到间隔为1时，进行最后一次直接插入排序，完成排序。
 */
public void ShellsSort(List<Students>list) {
	int gap, i, j;
    int n=list.size()-1;
    for (gap=n/2;gap>=1;gap=gap/2) {//取间隔
        for ( i=gap; i<=n;i++) {//分组
            for (j=i-gap;j>=0;j-=gap) {//直接插入排序
            	if(list.get(j).getAllscore()<list.get(j+gap).getAllscore()) {
            	 Students temp=list.get(j);
            	 list.set(j, list.get(j+gap));
            	 list.set(j+gap,temp );
            	}
            }
        }
    }
}

快速排序：Quicksort()

/*
 * @param list 待排序线性表
 * @param left 左边界
 * @param right 右边界
 * 选定一个基础basic，left指向左边第一个数，right指向右边最后一个数
 * left先移动，如果向右移动的过程中，遇见比basic大的数，停止移动，然后right移动。
 * right向左移动的过程中，遇见比basic小的数，停止移动，交换left和right所对应的数的位置，然后重复上面步骤。直到left和right指向同一个数时，将该数和basic进行交换。
 * 完成上面步骤后，递归左子序列和右子序列，完成排序。
 */
public void Quicksort( List <Students>list,int left,int right){
    if (left > right) {
        return;
    }
    int i = left;
    int j = right;
    Students basic = list.get(left);
    while (i != j){
    	while (list.get(i).getAllscore() >= basic.getAllscore()&& (j > i)) {
            i++;
        }
        while (list.get(j).getAllscore() <= basic.getAllscore()&& (j > i)) {
            j--;
        }
        //交换位置
        if (i < j) {
            Students temp=list.get(i);
            list.set(i,list.get(j));
            list.set(j,temp);
        }
    }
    list.set(left,list.get(i));
    list.set(i,basic);
    //递归左子序列
    Quicksort(list,left, --i);
    //递归右子序列
    Quicksort(list,++j, right);
}

堆排序：Heapsort

/*
 * 堆排序
 * @param list
 * 1、将带排序的序列构造成一个小顶堆，根据小顶堆的性质，当前堆的根节点（堆顶）就是序列中最小的元素；
 *2、 将堆顶元素和最后一个元素交换，然后将剩下的节点重新构造成一个小顶堆；
 * 3、重复步骤2，如此反复，从第一次构建小顶堆开始，每一次构建，我们都能获得一个序列的最大值，然后把它放到小顶堆的尾部。最后，就得到一个有序的序列了。
 *  
  */
public void Heapsort(List<Students> list)
{
	//初始建堆，从叶结点到根结点
    for (int i = list.size()/2+1; i >= 0; i--) {
        HeapAdjust(list, i, list.size()-1);
    }
    int n=list.size()-1;
    for (int i = 0; i <=n; i++) {
	Students temp = list.get(0);
	list.set(0, list.get(n-i));
	list.set(n-i, temp);
	HeapAdjust(list, 0, n-i-1);
    }
}
/**
 * 创建小根堆
 * @param list
 * @param parent 父结点
 * @param length 最大下标
 */
void HeapAdjust(List<Students> list, int parent, int length)
{
    Students temp = list.get(parent);
    int child = 2 * parent + 1;
    //如果有有孩子结点，且有孩子结点大于右孩子结点，则选取右孩子结点
    while (child < length) {
	if (child + 1 < length && list.get(child).getAllscore() > list.get(child+1).getAllscore()) {
	    child++;
	}
	//如果父结点的值已经小于孩子结点的值，则直接结束
	if (temp.getAllscore() <= list.get(child).getAllscore()) {
	    break;
	}
	//父结点和孩子结点交换，位置变换
	list.set(parent, list.get(child));
	parent = child;
	child = child * 2 + 1;
    }
    list.set(parent, temp);
}

返回所有学生信息：getAll()

/*
 * 返回所有学生信息
 */
public List<Students> getAll() {
	return database.getstudents();
}

StudentsSystem类

简介：该类主要是对各种函数的调用，形成一个系统服务平台

    public class StudentsSystem {
 private Scanner scanner = new Scanner(System.in);
    private StudentsDao studentsdao;
    private Text text;
    public StudentsSystem(Text text) {
        this.text=text;
        this.studentsdao=new StudentsDao(text);
    }

菜单

/**
 * 系统菜单
 */
public void show() {
	System.out.println("0.结束");
    System.out.println("1.查看所有在库学生信息");
    System.out.println("2.学生排名查询");
    System.out.println("3.学生信息管理");
    System.out.println("4.学生信息查询");
    System.out.println("请输入你的选择：");
    String choose=scanner.next();
    switch(choose) {

退出系统

    case"0":
    	System.out.print("成功退出系统。");
    	break;

查看所有在库学生信息

    case"1":
    	List<Students>list0=text.getstudents();
    	studentsdao.ShakerSort(list0);
    	studentsdao.sortStudent();
    	showAllText();
    	System.out.println("输入“0”返回菜单，任意键结束。");
    	String num1=scanner.next();
    	if(num1.equals("0")){
    		show();
    	}else {
    		break;
    	}
    	break;

学生排名查询

    case"2":
    	System.out.println("请选择查看排名排序方式：");
    	System.out.println("1、双向冒泡排序");
    	System.out.println("2、希尔排序");
    	System.out.println("3、快速排序");
    	System.out.println("4、堆排序");
    	String choose2=scanner.next();
    	switch(choose2) {
    	case"1":
    		List<Students>list=text.getstudents();
    		studentsdao.ShakerSort(list);
    		studentsdao.print();
    		System.out.println("输入“0”返回菜单，任意键结束。");
        	String num2=scanner.next();
        	if(num2.equals("0")){
        		show();
        	}else {
        		break;
        	}
        	break;
    	case"2":
    		List<Students>list1=text.getstudents();
    		studentsdao.ShellsSort(list1);
    		studentsdao.print();
    		System.out.println("输入“0”返回菜单，任意键结束。");
        	String num3=scanner.next();
        	if(num3.equals("0")){
        		show();
        	}else {
        		break;
        	}
        	break;
    	case"3":
    		List<Students>list3=text.getstudents();
    		studentsdao.Quicksort(list3,0,list3.size()-1);
    		studentsdao.sortStudent();
    		studentsdao.print();
    		System.out.println("输入“0”返回菜单，任意键结束。");
        	String num4=scanner.next();
        	if(num4.equals("0")){
        		show();
        	}else {
        		break;
        	}
        	break;
    	case"4":
    		List<Students>list4=text.getstudents();
    		studentsdao.Heapsort(list4);
    		studentsdao.sortStudent();
    		studentsdao.print();
    		System.out.println("输入“0”返回菜单，任意键结束。");
        	String num5=scanner.next();
        	if(num5.equals("0")){
        		show();
        	}else {
        		break;
        	}
        	break;
    	 default:
             System.out.println("输入错误!请重新输入：");
             show();
    	}
    	break;

学生信息管理

    case"3":
    	System.out.println("1.新增学生信息");
        System.out.println("2.删除学生信息");
        System.out.println("3.修改学生信息");
        System.out.println("请输入你的选择(输入“0”返回菜单)：");
        String choose3=scanner.next();
        switch(choose3) {
       System.out.println("请输入学生学号：");
            int studentsID=toInt(scanner.next());
            List<Students>list=text.getstudents();
            int numa=0;
            for(int i=0;i<list.size();i++){
            	int id=list.get(i).studentsId();
            	if(studentsID==id){
            		numa++;
                }
            }
            if(numa==1) {
            	System.out.println("该学生已在库，系统自动返回菜单。");
        		show();
        		}else {
                	System.out.println("请输入学生姓名：");
                	String studentsname=scanner.next();
                	System.out.println("请输入学生专业：");
                	String studentssubject=scanner.next();
                	System.out.println("请输入学生高数成绩：");
                	double score1=toInt(scanner.next());
                	if(score1<0){
                        System.out.println("输入错误，返回菜单。");
                        show();
                    }
                	System.out.println("请输入学生大物成绩：");
                	double score2=toInt(scanner.next());
                	if(score2<0){
                        System.out.println("输入错误，返回菜单。");
                        show();
                    }
                	System.out.println("请输入学生英语成绩：");
                	double score3=toInt(scanner.next());
                	if(score3<0){
                        System.out.println("输入错误，返回菜单。");
                        show();
                    }
                	System.out.println("请输入学生毛概成绩：");
                	double score4=toInt(scanner.next());
                	if(score4<0){
                        System.out.println("输入错误，返回菜单。");
                        show();
                    }
                	studentsdao.insert(new Students(studentsID,studentsname,studentssubject,score1,score2,score3,score4));
                	studentsdao.sortStudent();
                    text.update();
                	System.out.println("输入“0”返回菜单，任意键结束。");
                	String result=scanner.next();
                	if(result.equals("0")) {
                		show();
                	}else {
                		break;
                	}  
            	}
            break;
            	case"2":
        	    System.out.println("请输入学生的学号：");
        	    int studentsID1=toInt(scanner.next());
                List<Students>list1=text.getstudents();
                int num=0;
                for(int i=0;i<list1.size();i++){
                	int id=list1.get(i).studentsId();
                	if(studentsID1==id){
                		num++;
                		System.out.println("该学生信息已被删除！");
                		studentsdao.delete(studentsID1);
                		studentsdao.sortStudent();
                        text.update();
                		show();
                		}
                }
                if(num==1) {
                	
                }else {
                	System.out.println("系统中未存在该学生。");
                	show();
                }
                break;
               case"3":
                	System.out.println("请输入需要修改的学生学号：");
                	int studentsID3=toInt(scanner.next()); 
                	int num3=0;
                	List<Students>list2=text.getstudents();
                	for(int i=0;i<list2.size();i++){
                		int id=list2.get(i).studentsId();
                		if(studentsID3==id){
                			num3++;
                			}
                	}
                	if(num3==1) {
                		System.out.println("请输入学生高数成绩：");
            			double score1=toInt(scanner.next());
            			if(score1<0){
            				System.out.println("输入错误，返回菜单。");                    				
            				show();
            				}
            			System.out.println("请输入学生大物成绩：");
            			double score2=toInt(scanner.next());
            			if(score2<0){
            				System.out.println("输入错误，返回菜单。");     
            				show();
            				}
            			System.out.println("请输入学生英语成绩：");
            			double score3=toInt(scanner.next());
            			if(score3<0){
            				System.out.println("输入错误，返回菜单。");                    				
            				show();
            				}
            			System.out.println("请输入学生毛概成绩：");
            			double score4=toInt(scanner.next());
            			if(score4<0){
            				System.out.println("输入错误，返回菜单。");
            				show();
            				}
            			studentsdao.modify(studentsID3, score1, score2, score3, score4);//可能会有问题
            			studentsdao.ShakerSort(list2);
            			studentsdao.sortStudent();
                        text.update();
            			show();
                    }else {
                    	System.out.println("系统中未存在该学生。");
                    	show();
                    }
                	break;
                	default:
                		System.out.println("输入错误!返回菜单");
                		show();
                		}
        break;

学生信息查询

    case"4":
    	System.out.println("1.学号查询");
    	System.out.println("2.姓名查询");
    	System.out.println("请输入查询方式：");
    	String choose4=scanner.next();
    	switch(choose4) {
    	case"1":
    		System.out.println("请输入学号：");
    		int id1=toInt(scanner.next());
            List<Students>list3=text.getstudents();
            for(int i=0;i<list3.size();i++){
            	int id=list3.get(i).studentsId();
            	if(id1==id){
            		studentsdao.xhshow(id);
            		show();
            		}             		
            	}
            break;
    	case"2":
    		System.out.println("请输入学生姓名：");
    		String name1=scanner.next();
    		List<Students>list4=text.getstudents();
    		for(int i=0;i<list4.size();i++){
            	String name=list4.get(i).name();
            	if(name1.equals(name)){
            		studentsdao.xmshow(name);
            		show();
                }
    		}
    		break;
    		default:
    			System.out.println("输入错误!返回菜单");
    			show();
    			}
    	break;
    default:
        System.out.println("输入错误!请重新输入：");
        show();
    	}
    }

输入异常处理：toInt()

/*
 * int类型输入控制函数，如：系统要求你输入int类型，如果你输入其他类型，系统将其转换为int类型
 */
public int toInt(String a){
    try {
        int result=Double.valueOf(a).intValue();
        return result<0?0:result;
    }catch (Exception e){
        return -1;
    }
}

显示所有学生信息：showAllText()

/*
 * 显示所有信息
 */
public void showAllText(){
    System.out.println("学号        "+"姓名   "+"专业   "+"高数      "+"大物        "+"英语         "+"毛概       "+"总分         "+"名次 ");
    for (Students stu:studentsdao.getAll()){
        stu.showAll();
    }
}
}

Text类

简介：该类用于文本的读写。

文本的读取

public class Text {
	private List<Students> students=new ArrayList<Students>();
	BufferedReader br;
	BufferedWriter out;
	String fileName="./Text.txt";
public Text() throws IOException {
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream(fileName), "UTF-8"));
            String lines = null;
            String[] texts= null;
            do {
            	lines = br.readLine();
                if (lines != null) {
                	texts= lines.split(",");
                    System.out.println(Arrays.toString(texts));
                } else {
                    break;
                }
                if (texts != null && texts.length == 7) {
                	students.add(new Students(texts[0], texts[1], texts[2], texts[3], texts[4], texts[5], texts[6]));
                } else if (texts.length == 9) {
                	students.add(new Students(texts[0], texts[1], texts[2], texts[3], texts[4],texts[5], texts[6], texts[7], texts[8]));
                }
            } while (lines != null);        
        } catch (UnsupportedEncodingException unsupportedEncodingException) {
            unsupportedEncodingException.printStackTrace();
        } catch (FileNotFoundException fileNotFoundException) {
            fileNotFoundException.printStackTrace();
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
        br.close();
    }

文本的重写及更新

  /**
 * 根据线性表重写文件，更新学生信息
 */
public void update() {
    //文本内容的跟新
    try {
        out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName, false)));
        for (Students ele : students) {
            try {
                out.write(ele.getAllInfo() + '\n');
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        out.flush(); 
        out.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
public void setStudents(List<Students> students) {
    this.students = students;
}
public List<Students> getstudents() {
	// TODO 自动生成的方法存根
	return students;
}

test类

简介：创建对象，运行该系统。

public class test {
	public static void main(String[] args){
		Text database=null;
        try {
            database = new Text();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //创建数据库实例对象
        StudentsSystem sys = new StudentsSystem(database);
        //启动系统
        sys.show();
    }
}

运行截图

开始运行会对文本进行读取

在这里插入图片描述

进行名次排序

这里选用的是希尔排序，排序完成后，文本会进行更新

新增学生信息

首先我们输出系统中已存在的学号，看是否会报错
在这里插入图片描述
接着我们新增一个同名的学生信息，用于后面姓名查询的检验

删除学生信息

这里我们将王二通过输入学号进行删除
在这里插入图片描述

修改学生信息

这里我们将刘明的成绩全改为0
在这里插入图片描述

查找学生信息

通过学号查找

这里我们通过输入张三的学号查找张三学生信息
在这里插入图片描述

通过姓名查询

新增学生信息时，我们新增了一个同名的李华，现在我们来查询学生姓名为“李华”的信息。
在这里插入图片描述
因为查询时，我们遍历了整个链表，所以匹配成功时，都会打印输入改学生的学生信息。

暮榆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学生信息管理系统

文章目录Students类StudentsDao类StudentsSystem类Text类test类Students类简介：学生基本属性public class Students {private String name;private int studentsId;private String subject;private double score1;private double score2;private double score3;private double score4;
复制链接

扫一扫