对象输入输出流+Comparable接口和compareTo()函数案例_java

1 自定义文件，存放某班级学生期末各科考试原始成绩

​1、创建Student实体类，注意Student实体类需要实现Serializable, Comparable这两个接口，Serializable接口没有任何重写的方法，继承的目的是标志该类的对象是可以序列化和反序列化的。Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。​如果add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。​​

​compareTo方法的返回值是int，有三种情况：
（1）比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数
（2）比较者等于被比较者，那么返回0
（3）比较者小于被比较者，那么返回负整数​

import java.io.Serializable;

public class Student implements Serializable, Comparable<Student> {
    private String name;//姓名
    private String studentID;//学号
    private int English;//英语成绩
    private int Java;//Java成绩
    private int Python;//Python成绩

    //构造方法
    public Student(String name, String studentID, int english, int java, int python) {
        this.name = name;
        this.studentID = studentID;
        English = english;
        Java = java;
        Python = python;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStudentID(String studentID) {
        this.studentID = studentID;
    }

    public void setEnglish(int english) {
        English = english;
    }

    public void setJava(int java) {
        Java = java;
    }

    public void setPython(int python) {
        Python = python;
    }

    public String getName() {
        return name;
    }

    public String getStudentID() {
        return studentID;
    }

    public int getEnglish() {
        return English;
    }

    public int getJava() {
        return Java;
    }

    public int getPython() {
        return Python;
    }

    @Override
    public int compareTo(Student o) {
        return this.getJava() - o.getJava();//按照java成绩从小到大
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", studentID='" + studentID + '\'' +
                ", English=" + English +
                ", Java=" + Java +
                ", Python=" + Python +
                '}';
    }
}

​2、创建一个容器，将5位同学的相关信息加入到容器中。​

ArrayList<Student> arrayList = new ArrayList<Student>();
//将5个学生对象添加到容器中
arrayList.add(new Student("李一", "201916001", 80, 88, 90));
arrayList.add(new Student("李二", "201916002", 54, 80, 75));
arrayList.add(new Student("李三", "201916003", 47, 69, 70));
arrayList.add(new Student("李四", "201916004", 87, 93, 60));
arrayList.add(new Student("李五", "201916005", 75, 72, 88));

​3、将学生原始信息写入磁盘文件，在D盘下建立score.txt文件，这里使用ObjectOutputStream对象输出流进行存储（对象序列化）。ObjectOutputStream对象obs调用writeObjecct(arrayList)方法，将参数（对象）写入到文件。​

try {
     //创建一个ObjectOutputStream对象输出流
     ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("D:\\score.txt"));
  //将容器内对象写到文件中
     obs.writeObject(arrayList);
     obs.flush();
        System.out.println("文件写入成功，序列化完毕！");
     } catch (IOException e) {
         e.printStackTrace();
}

2 读取上述原始成绩文件，按照某门课程分数高低排序

​在Student实体类继承了Comparable下重写排序方法，compareTo()，这样可以直接使用Collections的sort()方法对对象内容进行排序。​

Collections.sort(arrayList);

​排序后输出到屏幕上，遍历arrayList容器即可，这里使用两种方法，第一种是增强for循环，第二种使用的是使用Java迭代器Iterator​

//第一种遍历
for (Student student : arrayList
) {
    System.out.println(student);
}

//第二种遍历
Iterator it = arrayList.iterator();
 while (it.hasNext()) {
    Student s = (Student) it.next();
    System.out.println(s);
}

​打印在屏幕上完成后，再次将排好序的信息存入到新的文件地址re_score.txt中。同理这里使用ObjectOutputStream对象输出流进行存储（对象序列化）。ObjectOutputStream对象obs调用writeObjecct(arrayList)方法，将参数（对象）写入到文件。​

try {//将排好序的容器里的对象再次写到文件中
     //创建一个ObjectOutputStream对象输出流
    ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("D:\\re_score.txt"));
//将容器内对象写到文件中
    obs.writeObject(arrayList);
    obs.flush();
    System.out.println("学生信息排序后再次写入新文件re_score.txt,写入成功\n");
} catch (IOException e) {
   e.printStackTrace();
}

3 输出排序后的新文件，并在屏幕上显示某门课挂科详情

​将D:\re_score.txt文件中排好序的信息读取出来，这里使用ObjectInputStream对象输入流，从ObjectInputStream对象输入流中读取一个对象，并强制转换成ArrayList类型。输出到屏幕上并统计某门课的挂科情况。​

try {//将排好序的文件内容读出来，打印到屏幕上
    //创建一个ObjectInputStream对象输入流
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\re_score.txt"));
    //从ObjectInputStream对象输入流中读取一个对象，并强制转换成ArrayList类型
    ArrayList arrayList1 = (ArrayList) in.readObject();

    System.out.println("re_score.txt文件内容中，Java成绩不及格的情况如下：");
    Iterator iterator = arrayList1.iterator();
    while (iterator.hasNext()) {
        Student s = (Student) iterator.next();
        if (s.getJava() < 60){
            System.out.println(s);   
        }
    }
} catch (IOException | ClassNotFoundException e) {
   e.printStackTrace();
}

4 完整代码

​Student.java​

package Student;

import java.io.Serializable;

public class Student implements Serializable, Comparable<Student> {
    private String name;//姓名
    private String studentID;//学号
    private int English;//英语成绩
    private int Java;//Java成绩
    private int Python;//Python成绩

    //构造方法
    public Student(String name, String studentID, int english, int java, int python) {
        this.name = name;
        this.studentID = studentID;
        English = english;
        Java = java;
        Python = python;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStudentID(String studentID) {
        this.studentID = studentID;
    }

    public void setEnglish(int english) {
        English = english;
    }

    public void setJava(int java) {
        Java = java;
    }

    public void setPython(int python) {
        Python = python;
    }

    public String getName() {
        return name;
    }

    public String getStudentID() {
        return studentID;
    }

    public int getEnglish() {
        return English;
    }

    public int getJava() {
        return Java;
    }

    public int getPython() {
        return Python;
    }

    @Override
    public int compareTo(Student o) {
        return this.getJava() - o.getJava();//按照java成绩从小到大
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", studentID='" + studentID + '\'' +
                ", English=" + English +
                ", Java=" + Java +
                ", Python=" + Python +
                '}';
    }
}

​Test.java​

package Student;

import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> arrayList = new ArrayList<Student>();
        //将5个学生对象添加到容器中
        arrayList.add(new Student("李一", "201916001", 80, 59, 90));
        arrayList.add(new Student("李二", "201916002", 54, 10, 75));
        arrayList.add(new Student("李三", "201916003", 47, 69, 70));
        arrayList.add(new Student("李四", "201916004", 87, 93, 60));
        arrayList.add(new Student("李五", "201916005", 75, 72, 88));

        try {
            //创建一个ObjectOutputStream对象输出流
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("D:\\score.txt"));
//            将容器内对象写到文件中
            obs.writeObject(arrayList);
            obs.flush();
            System.out.println("文件写入成功，序列化完毕！\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("D:\\score.txt中文件内容为：");
//        第一种遍历方法
//        for (Student student : arrayList
//        ) {
//            System.out.println(student);
//        }
        //第二种遍历方法
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s);
        }

        //排序
        Collections.sort(arrayList);
        System.out.println("\n按照Java成绩从小到大排序为：");
        for (Student student : arrayList
        ) {
            System.out.println(student);
        }

        try {//将排好序的容器里的对象再次写到文件中
            //创建一个ObjectOutputStream对象输出流
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("D:\\re_score.txt"));
//            将容器内对象写到文件中
            obs.writeObject(arrayList);
            obs.flush();
            System.out.println("学生信息排序后再次写入新文件re_score.txt,写入成功\n");
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {//将排好序的文件内容读出来，打印到屏幕上
            //创建一个ObjectInputStream对象输入流
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\re_score.txt"));
            //从ObjectInputStream对象输入流中读取一个对象，并强制转换成ArrayList类型
            ArrayList arrayList1 = (ArrayList) in.readObject();

            System.out.println("re_score.txt文件内容中，Java成绩不及格的情况如下：");
            Iterator iterator = arrayList1.iterator();
            while (iterator.hasNext()) {
                Student s = (Student) iterator.next();
                if (s.getJava() < 60){
                    System.out.println(s);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

对象输入输出流+Comparable接口和compareTo()函数案例_序列化_02

​运行结果为：​

对象输入输出流+Comparable接口和compareTo()函数案例_后端_03