题目1:学生成绩档案管理系统(代码实现)
学生类
package Pojo;
import java.util.Objects;
public class StudentNode {
private int id;
private String name;
private String major;
private double math_grade;
private double english_grade;
private double java_grade;
private double cpp_grade;
private double all_grade;
private int sort;
public StudentNode() {
}
public StudentNode(int id, String name, String major, double math_grade,
double english_grade, double java_grade, double cpp_grade,
double all_grade, int sort) {
this.id = id;
this.name = name;
this.major = major;
this.math_grade = math_grade;
this.english_grade = english_grade;
this.java_grade = java_grade;
this.cpp_grade = cpp_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 math_grade;
}
public void setMath_grade(double math_grade) {
this.math_grade = math_grade;
}
public double getEnglish_grade() {
return english_grade;
}
public void setEnglish_grade(double english_grade) {
this.english_grade = english_grade;
}
public double getJava_grade() {
return java_grade;
}
public void setJava_grade(double java_grade) {
this.java_grade = java_grade;
}
public double getCpp_grade() {
return cpp_grade;
}
public void setCpp_grade(double cpp_grade) {
this.cpp_grade = cpp_grade;
}
public void setAll_grade() {
this.all_grade = this.math_grade + this.english_grade + this.java_grade + this.cpp_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.math_grade, math_grade) == 0 &&
Double.compare(that.english_grade, english_grade) == 0 &&
Double.compare(that.java_grade, java_grade) == 0 &&
Double.compare(that.cpp_grade, cpp_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, math_grade, english_grade,
java_grade, cpp_grade, all_grade, sort);
}
public String toString() {
return id + "\t" + name + "\t" + major + "\t" + math_grade + "\t" + english_grade + "\t" +
java_grade + "\t" + cpp_grade + "\t" + all_grade + "\t" + sort;
}
}
数据交互类
1.读写功能
package Data;
import java.io.*;
import java.util.ArrayList;
public class Write_Read {
public BufferedReader br;
public BufferedWriter bw;
public File file = new File("D:\\JAVA\\Data_struct\\src\\student");
public Write_Read() {
}
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;
}
}
2.数据库类
package Data;
import Pojo.StudentNode;
import java.util.ArrayList;
public class Database {
public Write_Read rw = new Write_Read();
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);
}
}
数据访问对象类
package Dao;
import Data.Database;
public class StudentDao {
private Database database;
public StudentDao(Database database) {
this.database = database;
}
public Database getDatabase() {
return database;
}
}
系统服务类
package Service;
import Compare.Compare;
import Dao.StudentDao;
import Data.Database;
import Pojo.StudentNode;
import Sort.DoubleSort;
import Sort.HeapSort;
import Sort.QuickSort;
import Sort.ShellSort;
import java.util.Collections;
import java.util.Scanner;
public class Service {
private Scanner key = new Scanner(System.in);
private StudentDao studentDao;
private DoubleSort Doublesort = new DoubleSort();
private HeapSort heapsort = new HeapSort();
private QuickSort quicksort = new QuickSort();
private ShellSort shellsort = new ShellSort();
public Service(Database database) {
studentDao = new StudentDao(database);
}
/**
* 起始菜单
*/
public void start() {
System.out.println("*****欢迎使用学生档案管理系统*****");
mean();
}
public void mean() {
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("请选择:");
int choice = key.nextInt();
switch (choice) {
case 1:
browse();//浏览学生信息
break;
case 2:
add();//新增学生信息
break;
case 3:
find();//查找学生信息
break;
case 4:
save();//保存学生信息
break;
case 5:
load();//加载学生信息
break;
case 6:
exit();//退出系统
break;
default:
System.out.println("输入错误,请重新输入");
mean();
}
}
/**
* 浏览学生信息
*/
public void browse() {
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:
Doublesort.sortByAll(studentDao.getDatabase().list);
break;
case 2:
shellsort.sortByAll(studentDao.getDatabase().list);
break;
case 3:
quicksort.sortByAll(studentDao.getDatabase().list, 0, studentDao.getDatabase().list.size() - 1);
break;
case 4:
heapsort.sortByAll(studentDao.getDatabase().list);
break;
default:
System.out.println("无效选择,请重新输入:");
browse();
}
System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "数学" + "\t" +
"英语" + "\t" + "Java" + "\t" + "C++" + "\t\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 chooice = key.nextInt();
switch (chooice) {
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 = serachById(id);
if (student == null) {
System.out.println("没有找到该学生,请重新输入");
modification();
} else {
System.out.println("成功找到该学生信息,并为您成功打印");
System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "数学" + "\t" +
"英语" + "\t" + "Java" + "\t" + "C++" + "\t\t" + "总成绩" + "\t" + "排名");
System.out.println(student.toString());
//修改学生信息
modification2(student);
}
}
/**
* 确认是否修改
*/
public void modification2(StudentNode student) {
System.out.println("请问是否确认修改该学生信息");
System.out.println("确认请输入y,不确认请输入n");
String chooice = key.next();
if (chooice.equals("y")) {
// 修改学生信息
modification3(student);
} else if (chooice.equals("n")) {
System.out.println("为您返回学生信息");
browse();
} else {
System.out.println("输入错误,请重新输入");
modification2(student);
}
}
/**
* 修改学生信息
*/
public void modification3(StudentNode student) {
System.out.println("请输入您要修改的项目");
System.out.println("1.数学");
System.out.println("2.英语");
System.out.println("3.Java");
System.out.println("4.C++");
int chooice = key.nextInt();
switch (chooice) {
case 1:
System.out.println("您要修改的项目为数学成绩");
System.out.println("请输入修改后的值");
double math_grade = key.nextDouble();
student.setMath_grade(math_grade);
student.setAll_grade();
break;
case 2:
System.out.println("您要修改的项目为英语成绩");
System.out.println("请输入修改后的值");
double english_grade = key.nextDouble();
student.setEnglish_grade(english_grade);
student.setAll_grade();
break;
case 3:
System.out.println("您要修改的项目为Java成绩");
System.out.println("请输入修改后的值");
double java_grade = key.nextDouble();
student.setJava_grade(java_grade);
student.setAll_grade();
break;
case 4:
System.out.println("您要修改的项目为C++成绩");
System.out.println("请输入修改后的值");
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("是请输入y,否请输入n");
String chooice = key.next();
if (chooice.equals("y")) {
// 修改学生信息
modification3(student);
} else if (chooice.equals("n")) {
System.out.println("为您返回学生信息");
browse();
} else {
System.out.println("输入错误,请重新输入");
modification4(student);
}
}
/**
* 查找需要删除学生的信息
*/
public void delete() {
StudentNode student = null;
System.out.println("请输入您要删除的学生学号");
int id = key.nextInt();
student = serachById(id);
if (student == null) {
System.out.println("没有找到该学生,请重新输入");
delete();
} else {
System.out.println("成功找到该学生信息,并为您成功打印");
System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "数学" + "\t" +
"英语" + "\t" + "Java" + "\t" + "C++" + "\t\t" + "总成绩" + "\t" + "排名");
System.out.println(student.toString());
//删除学生信息
delete2(student);
}
}
/**
* 确认是否删除
*/
public void delete2(StudentNode student) {
System.out.println("请问是否确认删除该学生信息");
System.out.println("确认请输入y,不确认请输入n");
String chooice = key.next();
if (chooice.equals("y")) {
// 删除学生信息
delete3(student);
} else if (chooice.equals("n")) {
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("是请输入y,否请输入n");
String chooice = key.next();
if (chooice.equals("y")) {
// 删除学生信息
delete();
} else if (chooice.equals("n")) {
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("请输入数学成绩");
double math_grade = key.nextDouble();
System.out.println("请输入英语成绩");
double english_grade = key.nextDouble();
System.out.println("请输入Java成绩");
double java_grade = key.nextDouble();
System.out.println("请输入C++成绩");
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();
;
}
}
/**
* 检查学号是否与库中重复
*/
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 chooice = key.nextInt();
switch (chooice) {
case 1:
//学号查找
serachById();
break;
case 2:
//姓名查找
serachByName();
break;
default:
System.out.println("输入错误,请重新输入");
find();
}
}
/**
* 使用学号查找学生信息
*/
public void serachById() {
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("抱歉,没有找到该学号的学生");
nextBySerachById();
} else {
System.out.println("成功查找到学生信息,为您打印该学生的信息");
System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "数学" + "\t" +
"英语" + "\t" + "Java" + "\t" + "C++" + "\t\t" + "总成绩" + "\t" + "排名");
System.out.println(student.toString());
nextBySerach(student);
}
}
/**
* 使用学号查找学生信息(以删除修改信息为目的)
*
* @return
*/
public StudentNode serachById(int id) {
StudentNode student = null;
for (StudentNode s : studentDao.getDatabase().list) {
if (s.getId() == id) {
student = s;
}
}
return student;
}
/**
* 使用学号查找失败后的下一步操作
*/
public void nextBySerachById() {
System.out.println("查找失败,返回上一层!");
find();
}
/**
* 查找成功后的下一步操作
*/
public void nextBySerach(StudentNode student) {
System.out.println("请输入接下来的步骤");
System.out.println("1.修改学生信息");
System.out.println("2.删除学生信息");
System.out.println("3.返回初始菜单");
int chooice = key.nextInt();
switch (chooice) {
case 1:
modification3(student);
break;
case 2:
delete3(student);
break;
case 3:
mean();
break;
default:
System.out.println("输入错误,请重新输入");
nextBySerachById();
}
}
/**
* 使用姓名查找学生信息
*
*/
public void serachByName() {
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("抱歉,没有找到该姓名的学生");
nextBySerachByName();
} else {
System.out.println("成功查找到学生信息,为您打印学生的信息");
System.out.println("学号" + "\t" + "姓名" + "\t" + "专业" + "\t" + "数学" + "\t" +
"英语" + "\t" + "Java" + "\t" + "C++" + "\t\t" + "总成绩" + "\t" + "排名");
System.out.println(student.toString());
nextBySerach(student);
}
}
/**
* 使用姓名查找失败后的下一步操作
*/
public void nextBySerachByName() {
System.out.println("查找失败,返回上一层!");
find();
}
/**
* 保存学生信息
*/
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();
}
/**
* 退出系统
*/
public void exit() {
System.out.println("请确认您是否在退出前保存了您修改的信息");
System.out.println("确认请输入y,不确认请输入n");
String chooice = key.next();
if (chooice.equals("y")) {
System.out.println("欢迎下次使用,再见");
} else if (chooice.equals("n")) {
exit2();
} else {
System.out.println("输入错误,请重新输入");
exit();
}
}
/**
* 未保存信息退出
*/
public void exit2() {
System.out.println("请问是否需要保存此次修改");
System.out.println("需要请输入y,不需要请输入n");
String chooice1 = key.next();
if (chooice1.equals("y")) {
System.out.println("即将为您保存此次修改");
save();
System.out.println("保存成功,欢迎下次使用,再见");
} else if (chooice1.equals("n")) {
System.out.println("欢迎下次使用,再见");
} else {
System.out.println("输入错误,请重新输入");
exit2();
}
}
}
四个排序
1.双向冒泡
package Sort;
import Pojo.StudentNode;
import java.util.ArrayList;
public class DoubleSort {
/**
* 根据总成绩排序
*
* @param list
*/
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;
}
}
}
StudentNode student =new StudentNode();
for (StudentNode s:list) {
s.setSort(list.indexOf(s)+1);
if(s.getAll_grade()==student.getAll_grade()){
s.setSort(student.getSort());
}
student=s;
}
}
}
2.希尔排序
package Sort;
import Pojo.StudentNode;
import java.util.ArrayList;
public class ShellSort {
/**
* 根据总成绩排序
*
* @param list
*/
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);
}
}
StudentNode stu =new StudentNode();
for (StudentNode s:list) {
s.setSort(list.indexOf(s)+1);
if(s.getAll_grade()==stu.getAll_grade()){
s.setSort(stu.getSort());
}
stu=s;
}
}
}
3.快速排序
package Sort;
import Pojo.StudentNode;
import java.util.ArrayList;
public class QuickSort {
/**
* 根据总成绩排序
*
* @param list
* @param low
* @param high
*/
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);
StudentNode stu =new StudentNode();
for (StudentNode s:list) {
s.setSort(list.indexOf(s)+1);
if(s.getAll_grade()==stu.getAll_grade()){
s.setSort(stu.getSort());
}
stu=s;
}
}
}
4.堆排序
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);//调整最大的树
}
StudentNode stu =new StudentNode();
for (StudentNode s:list) {
s.setSort(list.indexOf(s)+1);
if(s.getAll_grade()==stu.getAll_grade()){
s.setSort(stu.getSort());
}
stu=s;
}
}
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);
}
}
主类
package Main;
import Data.Database;
import Service.Service;
public class Main {
public static void main(String[] args) {
Database database = new Database();
Service studentService = new Service(database);
studentService.start();
}
}
工具类
使文件保存时以学号顺序来保存
package Compare;
import Pojo.StudentNode;
import java.util.Comparator;
public class Compare implements Comparator<StudentNode> {
@Override
public int compare(StudentNode o1, StudentNode o2) {
if (o1.getId() > o2.getId())
return 1;
else
return -1;
}
}
学生信息文件
1001 小明 软件 80.5 77.5 86.5 77.0 321.5 4
1002 小红 软件 63.5 79.0 79.5 83.0 305.0 5
1003 李华 电子 100.0 100.0 100.0 100.0 400.0 1
1004 小吕 软件 100.0 100.0 100.0 60.0 360.0 3
1005 小紫 软件 100.0 100.0 100.0 100.0 400.0 1
README文件
#数据结构
数据结构实践
题目1:学生成绩档案管理系统
编程语言:Java
编译环境:JDK1.8
开发工具:IntelliJ IDEA