java 对象流（ObjectOutputStream，ObjectInputStream）

àì夳堔傛蜴生んèń 2022-06-10 12:45 109阅读 0赞

**对象流**  
  
ObjectInputStream ObjectOutputStream类分别是InputStream和OutputStream的子类，对象输出流使用writeObject(Object obj)方法，将一个对象obj写入到一个文件，使用readObject（）读取一个对象。  
  
**构造方法：**  
1. ObjectInputStream (InputStream in)  
2. ObjectOutputStream(OutputStream out)  
  
**代码示例：**  
  
1. 将对象写入文件：

//'序列化'的对象写入文件
           	OutputStream outputStream = new FileOutputStream(file);
           	ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
           	objectOutputStream.writeObject(Object obj);
           	objectOutputStream.close();

2. 从文件读取对象：  
  
  
  
注意：当使用对象流写入或者读取对象的时候，必须保证该对象是序列化的，这样是为了保证对象能够正确的写入文件，并能够把对象正确的读回程序。

//序列化读取对象
           	InputStream inputStream = new FileInputStream(file);
           	ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
           	Object obj = objectInputStream.readObject();
           	objectInputStream.close();

什么是对象序列化？  
  
**对象序列化**  
所谓的对象的序列化就是将对象转换成二进制数据流的一种实现手段，通过将对象序列化，可以方便的实现对象的传输及保存。在Java中提供了ObejctInputStream 和ObjectOutputStream这两个类用于序列化对象的操作。用于存储和读取对象的输入输出流类，要想实现对象的序列化需要实现Serializable接口，但是Serializable接口中没有定义任何的方法，仅仅被用作一种标记，以被编译器作特殊处理。

package main;
        
        import java.io.Serializable;
        //实现了Serializable接口。序列化
        public class Student implements Serializable {
        	//由编译器自动生成，用来解决不同的版本之间的序列化问题。 
        	private static final long serialVersionUID = -79485540193100816L;
        
        	private int age;
        	private String name;
        
        	public int getAge() {
        		return age;
        	}
        
        	public void setAge(int age) {
        		this.age = age;
        	}
        
        	public String getName() {
        		return name;
        	}
        
        	public void setName(String name) {
        		this.name = name;
        	}
        
        	public Student() {
        		super();
        	}
        
        	public Student(int age, String name) {
        		this.age = age;
        		this.name = name;
        	}
        
        }

**transient**  
  
1. 一旦变量被transient修饰，变量将不再是对象持久化(写到磁盘里持久保存)的一部分，该变量内容在序列化后无法获得访问。  
2. transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。  
3. 被transient关键字修饰的成员变量不再能被序列化。

4. \*静态变量不管是否被transient修饰，均不能被序列化。

示例代码：

package main;
    
    import java.io.Serializable;
    
    public class User implements Serializable {
    
    	private static final long serialVersionUID = -7751742801839580771L;
    	private String name;
    	private transient String passwrod;
    	private int age;
    	private transient double money;
    
    	public User(String name, String passwrod, int age, double money) {
    		super();
    		this.name = name;
    		this.passwrod = passwrod;
    		this.age = age;
    		this.money = money;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getPasswrod() {
    		return passwrod;
    	}
    
    	public void setPasswrod(String passwrod) {
    		this.passwrod = passwrod;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public double getMoney() {
    		return money;
    	}
    
    	public void setMoney(double money) {
    		this.money = money;
    	}
    
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", passwrod=" + passwrod + ", age=" + age + ", money=" + money + "]";
    	}
    
    }

package main;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class Main {
    
    	/**
    	 * 对象流
    	 * 
    	 * @param args
    	 */
    	public static void main(String[] args) {
    //		 writeObj();
    		readObj();
    	}
    
    	private static void writeObj() {
    		User user = new User("zhangsan", "123456", 18, 8888);
    		// 对象持久化
    		File file = new File("obj/users.obj");
    		try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));) {
    			oos.writeObject(user);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		System.out.println("写入完成");
    	}
    
    	private static void readObj() {
    		File file = new File("obj/users.obj");
    		try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));) {
    			Object obj = ois.readObject();
    			if (obj instanceof User) {
    				User u = (User) obj;
    				System.out.println(u);
    			}
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }