Java利用序列化与反序列化简单的实现一个可以离线的学生信息操作系统

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

学完简单的Java基础以后最常写的就是学生信息系统，了解了序列化以后，我把序列化运用在其中，将学生信息储存在集合中，每次关闭程序进行序列化，把对象集合序列化进本地，每次开启时再读取出来，这样每次的信息就可以保存下来。

提示：以下是本篇文章正文内容，下面案例可供参考

一、首先说一下什么是序列化

在 Java 中，序列化是一种将对象的状态转换为字节序列的机制，以便可以将对象持久化存储到磁盘文件中、通过网络传输或在不同的 Java 虚拟机之间传递对象。

序列化的主要作用：

对象持久化
可以将内存中的对象保存到文件中，以便在需要的时候重新加载恢复对象状态。例如，在一个游戏应用中，可以将玩家的游戏进度（包含玩家角色的各种属性、物品等对象）序列化后存储到文件中，下次玩家启动游戏时再读取文件进行反序列化，恢复游戏进度。
存储到数据库中时，也可以将对象序列化后以二进制大对象（BLOB）的形式存储。
网络传输
在分布式系统中，不同的节点可能需要通过网络进行通信。对象可以被序列化后在网络上传输，接收方再进行反序列化得到原始对象。比如在一个基于 Java 的分布式电商系统中，客户端将包含购物车信息的对象序列化后发送给服务器进行处理，服务器处理完后再将更新后的对象序列化返回给客户端。

二、反序列化

在 Java 中，反序列化是序列化的逆过程。它将存储在字节流中的对象状态信息转换回内存中的对象。

完整代码

核心功能代码：

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

//设计一个学生管理系统，包含学生类（Student id name age score），要求能够添加学生、删除学生、查找学生、计算平均分等功能。
public class studentControl_Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        HashMap<Integer, Student> arr = new HashMap<>(fanSerializ());
        HashMap<Integer, Student> arr = null;
        try {
            arr = fanSerializ();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (arr == null) {
            arr = new HashMap<>();
        }

        while (true) {
            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. 退出");

            Scanner sc = new Scanner(System.in);
            int choice = sc.nextInt();

            switch (choice) {
                case 1:
                    addStudent(arr);
                    break;
                case 2:
                    removeStudent(arr);
                    break;
                case 3:
                    findStudent(arr);
                    break;
                case 4:
                    averageScore(arr);
                    break;
                case 5:
                    getScore(arr);
                    break;
                case 6:
                    allStudent(arr);
                    break;
                case 7:
                    serializ(arr);
                    return;
                default:
                    System.out.println("无效的选择，请重新输入。");
            }
        }
    }

    private static void allStudent(HashMap<Integer, Student> arr) {
        if (arr.isEmpty()) {
            System.out.println("当前没有学生信息。");
            return;
        }
        for (Map.Entry<Integer, Student> entry : arr.entrySet()) {
            Student student = entry.getValue();
            System.out.println("学生ID: " + student.getId() + ", 姓名: " + student.getName() + ", 年龄: " + student.getAge() + ", 分数: " + student.getScore());
        }
    }

    //添加学生
    public static void addStudent(HashMap<Integer, Student> arr) throws IOException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生的 ID:");
        int id = sc.nextInt();
        System.out.println("请输入学生的姓名:");
        String name = sc.next();
        System.out.println("请输入学生的年龄:");
        int age = sc.nextInt();
        System.out.println("请输入学生的分数:");
        double score = sc.nextDouble();
        arr.put(id, new Student(id, name, age, score));
    }

    //删除学生
    public static void removeStudent(HashMap<Integer, Student> arr) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除学生的 ID:");
        int id = sc.nextInt();
        if (arr.containsKey(id)) {
            arr.remove(id);
            System.out.println("学生删除成功。");
        } else {
            System.out.println("未找到该学生，删除失败。");
        }
    }

    //查找学生
    public static void findStudent(HashMap<Integer, Student> arr) {
        Scanner sc = new Scanner(System.in);
        int id = sc.nextInt();
        System.out.println(arr.get(id));
    }

    //求分数平均值
    public static void averageScore(HashMap<Integer, Student> arr) {
        double sum = 0.0;
        int count = 0;
        for (Student student : arr.values()) {
            sum += student.getScore();
            count++;
        }
        if (!arr.isEmpty()) {
            double average = sum / count;
            System.out.println("全部学生平均分是：" + average);
        } else {
            System.out.println("无学生数据，无法求平均值");
        }
    }

    //拿到每个学生的分数
    public static void getScore(HashMap<Integer, Student> arr) {
        ArrayList<Double> scores = new ArrayList<>();
        for (Student student : arr.values()) {
            scores.add(student.getScore());
        }
        System.out.println(scores);
    }
    //对象序列化
    public static void serializ(HashMap<Integer, Student> arr) throws IOException {
        File file = new File("E://student/student.txt");
        try (FileOutputStream fos = new FileOutputStream(file);
             ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(arr);
        }
    }
    //反序列化
    public static HashMap<Integer, Student> fanSerializ() throws IOException, ClassNotFoundException {
        File file = new File("E://student/student.txt");
        if (!file.exists()) {
            System.out.println("首次运行，未找到序列化文件，创建空的 HashMap");
            return new HashMap<>();
        } else if (file.length() == 0) {
            System.out.println("文件为空");
            return null;
        }

        try (FileInputStream fis = new FileInputStream(file);
             ObjectInputStream ois = new ObjectInputStream(fis)) {

            return (HashMap<Integer, Student>) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

实体类：

import java.io.Serializable;
public class Student implements Serializable {
    private int id;
    private String name;
    private int age;
    private double score;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    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 int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public Student(int id, String name, int age, double score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
    }
}

总结

例如：本文对序列化以及反序列化应用到了非常常见的学生信息系统中，系统简单的实现了添加学生信息、删除学生信息、查找学生信息、计算平均值、获取所有学生分数、查看所有学生信息功能，如想扩充功能可自行实现。