实验一代码

Dao 包
package com.igek.Dao;
import com.igek.Data.Database;

public class StudentDao {
private Database database;

public StudentDao(Database database)
{
    this.database = database;
}

public Database getDatabase() {
    return database;
}

}
Data 包
package com.igek.Data;
import com.igek.pojo.Student;
import java.util.ArrayList;

public class Database {
public ReaderWriter rw = new ReaderWriter();
public ArrayList list = new ArrayList<>();

public Database() {
    ArrayList<String> list1 = rw.reader();
    for (String s : list1) {
        String student[] = s.split(" ");
        list.add(new Student(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<Student> list) {
    this.list = list;
}

/**
 * 保存信息
 */
public void save() {
    ArrayList<String> list1 = new ArrayList<>();
    for (Student 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 com.igek.Data;
import java.io.*;
import java.util.ArrayList;

public class ReaderWriter {
public BufferedReader br;
public BufferedWriter bw;
public File file = new File(“E:/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;
}

}
pojo包
package com.igek.pojo;
import java.util.Objects;

public class Student {
private int id;
private String name;
private String major;
private double 语文_grade;
private double 数学_grade;
private double 英语_grade;
private double 物理_grade;
private double all_grade;
private int sort;

public Student() {
}

public Student(int id, String name, String major, double 语文_grade,
               double 数学_grade, double 英语_grade, double 物理_grade,
               double all_grade, int sort) {
    this.id = id;
    this.name = name;
    this.major = major;
    this.语文_grade = 语文_grade;
    this.数学_grade = 数学_grade;
    this.英语_grade = 英语_grade;
    this.物理_grade = 物理_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 语文_grade;
}

public void setMath_grade(double 语文_grade) {
    this.语文_grade = 语文_grade;
}

public double getEnglish_grade() {
    return 数学_grade;
}

public void setEnglish_grade(double 数学_grade) {
    this.数学_grade = 数学_grade;
}

public double getJava_grade() {
    return 英语_grade;
}

public void setJava_grade(double 英语_grade) {
    this.英语_grade = 英语_grade;
}

public double getCpp_grade() {
    return 物理_grade;
}

public void setCpp_grade(double 物理_grade) {
    this.物理_grade = 物理_grade;
}

public void setAll_grade() {
    this.all_grade = this.语文_grade + this.数学_grade + this.英语_grade + this.物理_grade;
}

public double getAll_grade() {
    return all_grade;
}

public int getSort() {
    return sort;
}

public void setSort(int sort) {
    this.sort = sort;
}


public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student that = (Student) o;
    return id == that.id &&
            Double.compare(that.语文_grade, 语文_grade) == 0 &&
            Double.compare(that.数学_grade, 数学_grade) == 0 &&
            Double.compare(that.英语_grade, 英语_grade) == 0 &&
            Double.compare(that.物理_grade, 物理_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, 语文_grade, 数学_grade,
            英语_grade, 物理_grade, all_grade, sort);
}

public String toString() {
    return id + "\t" + name + "\t" + major + "\t  " + 语文_grade + "\t    " + 数学_grade + "\t    " +
            英语_grade + "\t    " + 物理_grade + "\t    " + all_grade + "\t  " + sort;
}

}
tools包
package com.igek.tools;

import com.igek.pojo.Student;

import java.util.Comparator;

public class Compare implements Comparator {

public int compare(Student o1, Student o2) {
    if (o1.getId() > o2.getId())
        return 1;
    else
        return -1;
}

}
system包
package com.igek.system;

import com.igek.Dao.StudentDao;
import com.igek.Data.Database;
import com.igek.pojo.Student;
import com.igek.sort.BidirectionalBubbleSort;
import com.igek.sort.HeapSort;
import com.igek.sort.QuickSort;
import com.igek.sort.ShellSort;
import com.igek.tools.Compare;

import java.util.Collections;
import java.util.Scanner;

public class StudentSystem {
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 StudentSystem(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" + "语文成绩" + "\t" +
            "数学成绩" + "\t" + "英语成绩" + "\t" + "物理成绩" + "\t" + "总成绩" + "\t" + "排名");
    for (Student 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() {
    Student student = new Student();
    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" + "语文成绩" + "\t" +
                "数学成绩" + "\t" + "英语成绩" + "\t" + "物理成绩" + "\t" + "总成绩" + "\t" + "排名");
        System.out.println(student.toString());
        //修改学生信息
        modification2(student);
    }

}

/**
 * 确认是否修改
 *
 */
public void modification2(Student 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(Student student) {
    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:
            // 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("您要修改的项目为英语成绩");
            System.out.println("请输入修改后的英语成绩");
            double java_grade = key.nextDouble();
            student.setJava_grade(java_grade);
            student.setAll_grade();
            break;
        case 4:
            //  System.out.println("您要修改的项目为物理成绩");
            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(Student 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() {
    Student 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" + "语文成绩" + "\t" +
                "数学成绩" + "\t" + "英语成绩" + "\t" + "物理成绩" + "\t" + "总成绩" + "\t" + "排名");
        System.out.println(student.toString());
        //删除学生信息
        delete2(student);
    }
}

/**
 * 确认是否删除
 *
 */
public void delete2(Student 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(Student 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("请输入语文成绩");
        double math_grade = key.nextDouble();
        System.out.println("请输入数学成绩");
        double english_grade = key.nextDouble();
        System.out.println("请输入英语成绩");
        double java_grade = key.nextDouble();
        System.out.println("请输入物理成绩");
        double cpp_grade = key.nextDouble();
        double all_grade = math_grade + english_grade + java_grade + cpp_grade;
        int sort = studentDao.getDatabase().list.size() + 2;
        Student student = new Student(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 (Student 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() {
    Student student = null;
    System.out.println("请输入您要查找学生的学号");
    int id = key.nextInt();
    for (Student 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" + "语文成绩" + "\t" +
                "数学成绩" + "\t" + "英语成绩" + "\t" + "物理成绩" + "\t" + "总成绩" + "\t" + "排名");
        System.out.println(student.toString());
        nextBySearch(student);
    }
}

/**
 * 使用学号查找学生信息（以删除修改信息为目的）
 *
 */
public Student searchById(int id) {
    Student student = null;
    for (Student 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(Student 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() {
    Student student = null;
    System.out.println("请输入您要查找学生的姓名:");
    String name = key.next();
    for (Student 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" + "语文成绩" + "\t" +
                "数学成绩" + "\t" + "英语成绩" + "\t" + "物理成绩" + "\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();
}

}
sort（算法）包
1.package com.igek.sort;

import com.igek.pojo.Student;

import java.util.ArrayList;
public class BidirectionalBubbleSort {//【1】双向冒泡排序
//算法基本思想：从无序序列头部开始，进行两两比较，根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，
// 从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。算法的核心在于每次通过两两比较交换位置，
// 选出剩余无序序列里最大（小）的数据元素放到队尾。
/**
* 根据总成绩排序
*
*/
public void sortByAll(ArrayList 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()) {
Student 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()) {
Student student = list.get(j);
list.set(j, list.get(j - 1));
list.set(j - 1, student);
needNextPass = true;
}
}
}
for (Student s : list) {
s.setSort(list.indexOf(s) + 1);
}
}

}
2.package com.igek.sort;

import com.igek.pojo.Student;

import java.util.ArrayList;

public class HeapSort {//堆排序
//算法功能：进行排序算法基本思想：在堆的数据结构中，
// 堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：
/void scoreManage::heapp(student a, int i, int n) {
int j = 2 * i + 1;//找到当前结点的左孩子
student temp = a[i];//为值转化做准备
while (j < n) {
if (j + 1 < n && a[j].total_score < a[j + 1].total_score) ++j;//确保与父结点交换的是最大的孩子
if (temp.total_score > a[j].total_score) break;
else {
a[i] = a[j];
i = j;
j = 2 * i + 1;
}
}
a[i] = temp;
}
void scoreManage::heap_sort() {
student* a;
a = linktoarray();//链表数组
int n = total();//链表长度
for (int i = n / 2 - 1; i >= 0; i–)
heapp(a, i, n);
for (int i = n - 1; i >= 1; i–) {//逆序
student t;
t = a[0];
a[0] = a[i];
a[i] = t;
heapp(a, 0, i);
}
arrytolink(a);
}
*/
public void sortByAll(ArrayList list) {
//一次调整，最大值到了根节点
for (int i = (list.size() - 1 - 1) / 2; i >= 0; i–) {//i相当于start
adjust(list, i, list.size() - 1);
}
//最后一个值与根节点交换
Student student = new Student();
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 (Student s : list) {
s.setSort(list.indexOf(s) + 1);
}
}

public static void adjust(ArrayList<Student> list, int start, int end) {

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

}
3.package com.igek.sort;

import com.igek.pojo.Student;

import java.util.ArrayList;

public class QuickSort {//快速排序
//算法基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。
// 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

public void sortByAll(ArrayList<Student> list, int low, int high) {
    int i, j;
    Student 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 (Student s : list) {
        s.setSort(list.indexOf(s) + 1);
    }
}

}
4.package com.igek.sort;

import com.igek.pojo.Student;

import java.util.ArrayList;

public class ShellSort {//希尔排序,堆排序
//算法基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
// 先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，
// 即所有记录放在同一组中进行直接插入排序为止。
public void sortByAll(ArrayList 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();
Student 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 (Student s : list) {
s.setSort(list.indexOf(s) + 1);
}
}
}

main包
package com.igek.main;

import com.igek.system.StudentSystem;
import com.igek.Data.Database;

/**

• 创建其他类的对象，调用这些对象的方法。

*/
public class Main {
public static void main(String[] args) {
Database database = new Database();
StudentSystem studentService = new StudentSystem(database);
studentService.start();
}

}