1, Object serialization stream
ObjectOutputStream writes the original data type and graphics of Java objects to OutputStream. You can use ObjectInputStream to read (refactor) objects. Persistent storage of objects can be achieved by using streaming files. If the stream is a network socket stream, you can refactor the object on another host or in another process.
ObjectOutputStream: Construction method: ObjectOutputStream(OutputStream out)Create a write to the specified OutputStream of ObjectOutputStream. Serialize object method: writeObject(Object obj) Writes the specified object to the ObjectOutputStream.
package Object serialization stream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class ObjectOutputStreamDemo { public static void main(String[] args) throws IOException { // ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\IDEA\\IO flow\\Student information.txt")); //create object StudentDemo s = new StudentDemo("Shi xuhao", 20); oos.writeObject(s); //release oos.close(); } }
2, Object deserialization stream
To serialize or deserialize objects, you must implement the Serializable interface
Reason for deserialization failure: the original class has been changed, and the file of the class has changed. There are two or more classes with the same name in a project
Solution: set UID
private static final long serialVersionUID=42L;
package Object serialization stream; import java.io.Serializable; //To implement serialization or deserialization, the class must implement this interface public class StudentDemo implements Serializable { //Set serialization ID, //After the serialization id is set and the class is changed, it can still be serialized without failure // private static final long serialVersionUID=42L; String name; int id; transient int age;//Does not participate in the serialization process public StudentDemo() { } public StudentDemo(String name, int id) { this.name = name; this.id = id; } public String getName() { return name; } public int getId() { return id; } }
3, How to judge whether the object stream has been read to the end
Author: Huang shaocun, senior lecturer of kowtow dinglang. connect: https://blog.csdn.net/wolfcode_cn/article/details/80701035
For those who have used the object stream, it is clear that the object stream operates on objects. Objects stored one by one can only be read one by one. However, there is a problem that you can only read as many as you write. There is no judgment method to read to the end. If the reading exceeds, an exception java.io.EOFException will be thrown, How can we judge whether it is the last one if we want to be general?
Method 1
Convert multiple original objects into a collection object, and then obtain data from the collection object
@Test public void testObjectOutputStream() throws Exception { ObjectOutputStream ojbOs = new ObjectOutputStream(new FileOutputStream(new File("user.obj"))); // Storing objects with collections List<Student> list = new ArrayList<Student>(); list.add(new Student("willie", 18)); list.add(new Student("xiaoming", 18)); // Write object ojbOs.writeObject(list); ojbOs.close(); } @Test public void testObjectInputStream() throws Exception { ObjectInputStream ojbIs = new ObjectInputStream(new FileInputStream(new File("user.obj"))); // Read and fetch collection objects List<Student> list = (List<Student>)ojbIs.readObject(); // Edit collection list.forEach(System.out::println); ojbIs.close(); }
Method 2
Method 1 is a better solution. If you don't want to convert to a collection object, you can also add a flag before or after the stored object. You can add an int value at the first position to record the number of stored objects, or you can add a null at the end to mark the end. See if you already know how to solve it. If you don't know yet! It's all right. Put on the code
@Test public void testObjectOutputStream2() throws Exception { ObjectOutputStream ojbOs = new ObjectOutputStream(new FileOutputStream(new File("student.obj"))); // Write object ojbOs.writeObject(new Student("willie", 18)); ojbOs.writeObject(new Student("xiaoming", 18)); // Write a null object as the end identifier ojbOs.writeObject(null); ojbOs.close(); } @Test public void testObjectInputStream2() throws Exception { ObjectInputStream ojbIs = new ObjectInputStream(new FileInputStream(new File("student.obj"))); // Read and fetch collection objects Object obj = null; // Traverse the object until null is encountered while((obj = ojbIs.readObject()) != null){ Student stu =(Student)obj; System.out.println(stu); } ojbIs.close(); }
Method 3
Use the exception handling method. This is very simple. Just handle EOFException directly. When EOFException is encountered, it means that it has been read to the end
public void testObjectInputStream3() throws Exception { ObjectInputStream ojbIs = new ObjectInputStream(new FileInputStream(new File("student.obj"))); List<Student> list = new ArrayList<>(); try { // read object while(true){ Student stu = (Student)ojbIs.readObject(); list.add(stu); } } catch (Exception e) { // Operation after reading System.out.println(list); } ojbIs.close(); }