序列化追加的更优实现方案咨询及文件内容覆盖问题排查

Great question! The core issue here is that your current FileOutputStream overwrites the file instead of appending, and even if you switch to append mode, the default ObjectOutputStream writes a serialization header at the start of the file—multiple headers will corrupt your serialized data. Let's walk through some cleaner alternatives to your subclassing approach:

1. Fix Append Mode with a Custom ObjectOutputStream (Preserve Your Current Format) #

If you want to keep writing individual strings and student details like you are now, you can create a helper method that skips duplicate headers when appending. Here's how:

// Helper method to get an appendable ObjectOutputStream without duplicate headers
private static ObjectOutputStream getAppendableOOS(File file) throws IOException {
    if (file.length() == 0) {
        // First write: use normal ObjectOutputStream to add the header
        return new ObjectOutputStream(new FileOutputStream(file));
    } else {
        // Subsequent writes: skip the header by overriding writeStreamHeader
        FileOutputStream fos = new FileOutputStream(file, true);
        return new ObjectOutputStream(fos) {
            @Override
            protected void writeStreamHeader() throws IOException {
                reset(); // Reset instead of writing a new header
            }
        };
    }
}

Then update your Serialization method to use this helper:

public void Serialization() {
    try {
        File file = new File("EnrolledStudentsSerial.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
        ObjectOutputStream output = getAppendableOOS(file);
        
        output.writeObject("Course: " + this.name + "\n\nEnrolled Students: ");
        for (Student p_obj : StudentList) {
            String content = "\n\tStudent Name: " + p_obj.getName() + 
                             "\n\tStudent Department: " + p_obj.getDepartment() + 
                             "\n\tStudent Age: " + p_obj.getAge() + "\n";
            output.writeObject(content);
        }
        output.writeObject("\n");
        output.close();
    } catch (IOException ioe) {
        System.out.println("Error: " + ioe.getMessage());
    }
}

2. Serialize Entire Course Objects (Cleaner, More Idiomatic Java) #

Instead of writing raw strings, a better approach is to make your Course and Student classes implement Serializable, then serialize the entire objects. This is more maintainable and aligns with Java's serialization design.

First, update your classes:

import java.io.Serializable;
import java.util.Vector;

public class Course implements Serializable {
    private String name;
    private Vector<Student> StudentList = new Vector<>();
    
    // Add constructors, getters, setters as needed
}

public class Student implements Serializable {
    private String name;
    private String department;
    private int age;
    
    // Add constructors, getters, setters as needed
}

Then rewrite your serialization method to append full Course objects:

public void serializeCourse() {
    try {
        File file = new File("EnrolledStudentsSerial.txt");
        ObjectOutputStream output = getAppendableOOS(file); // Reuse the helper from above
        output.writeObject(this);
        output.close();
    } catch (IOException ioe) {
        System.out.println("Error: " + ioe.getMessage());
    }
}

To read all serialized courses later, use this method:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;

public static List<Course> loadAllCourses() {
    List<Course> courses = new ArrayList<>();
    try (ObjectInputStream input = new ObjectInputStream(new FileInputStream("EnrolledStudentsSerial.txt"))) {
        while (true) {
            try {
                Course course = (Course) input.readObject();
                courses.add(course);
            } catch (IOException e) {
                // EOFException means we've reached the end of the file
                break;
            }
        }
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    return courses;
}

3. Read-Modify-Write (For Small Files) #

If your serialized file will always be small, you can read all existing content, add the new data, then rewrite the entire file. This avoids header issues but isn't efficient for large datasets:

public void serializeCourseWithReadModifyWrite() {
    List<Course> existingCourses = loadAllCourses();
    existingCourses.add(this);
    
    try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("EnrolledStudentsSerial.txt"))) {
        for (Course course : existingCourses) {
            output.writeObject(course);
        }
    } catch (IOException ioe) {
        System.out.println("Error: " + ioe.getMessage());
    }
}

Recommendation #

Go with option 2—it's the most idiomatic Java approach, keeps your code clean, and makes it easier to maintain and extend later. Option 1 works if you need to stick to your original string-based output format.

内容的提问来源于stack exchange，提问作者user13933479