IO流-数据流、对象流(八)

数据流

数据流将“基本数据类型与字符串类型”只作为数据源。从而允许程序以与机器无关的方式从底层输入输出流中操作java基本数据类型与字符串类型

DataInputStream和DataOutputStream提供了可以存取与机器无关的所有java基础类型数据（如：int、double、String等）的方法。

数据输出流

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class DataOutputDemo {
      
      
    public static void main(String[] args) {
      
      
        DataOutputStream dos=null;
        try {
      
      
            //DataOutputStream是一个处理流，我们要在里面做一个节点流，我们需要做一个BufferedOutputStream字节的缓冲流再去套一个文件字节输出流，以文件作为输出的目的地
            dos=new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/data.txt")));
            dos.writeChar('a');
            dos.writeInt(10);
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            dos.writeUTF("你好尚学堂");
            dos.flush();
        }catch (Exception e){
      
      
            e.printStackTrace();
        }finally{
      
      
            try {
      
      
                if (dos!=null){
      
      
                    dos.close();
                }

            }catch (Exception e){
      
      
                e.printStackTrace();
            }
        }
    }
}

数据输入流

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;

public class DataInputDemo {
      
      
    public static void main(String[] args) {
      
      
        DataInputStream dis=null;
        try {
      
      
            dis=new DataInputStream(new BufferedInputStream(new FileInputStream("d:/data.txt")));
            //直接读取数据，注意：读取的顺序与要写入的顺序一样，否则不能正确读取数据
            System.out.println("char: "+dis.readChar());
            System.out.println("int: "+dis.readInt());
            System.out.println("double: "+dis.readDouble());
            System.out.println("boolean: "+dis.readBoolean());
            System.out.println("String: "+dis.readUTF());
        }catch (Exception e){
      
      
            e.printStackTrace();
        }finally {
      
      
            try {
      
      
                if (dis!=null){
      
      
                    dis.close();
                }
            }catch (Exception e){
      
      
                e.printStackTrace();
            }
        }
    }
}

对象流

对象的本质是用来组织和存储数据的，对象本身也是数据。那么能不能将对象存储到硬盘上的文件中呢？能不能将对象通过网络传输到另一个电脑呢？我们可以通过序列化和反序列化来实现这些需求。

java对象的序列化和反序列化：
- 当一个A设备的数据发送到 B时设备时，
- 把A设备的User对象变成字节，把字节放到数据包当中，然后通过网络，将数据包发送到B设备，这个就是序列化。
- B设备的数据包再去解包处理，再把字节变成一个对象，这就是反序列化。
序列化涉及的类和接口

ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable接口的类的对象才能被序列化，Serializable接口是一个空接口，只起到标记作用。

操作基本数据类型

我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能度java对象进行读写操作(字符串除外)，但是在对象流中除了能实现对基本数据类型进行读写操作以外，还可以对java对象进行读写操作。

写出基本数据类型数据

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamBasicTypeDemo {
        
        
    public static void main(String[] args) {
        
        
        ObjectOutputStream oos=null;
        try {
        
        
            oos =new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/sxt5.txt")));
            oos.writeInt(10);
            oos.writeDouble(Math.random());
            oos.writeChar('a');
            oos.writeBoolean(true);
            oos.writeUTF("你好Oldlu");
            oos.flush();
        }catch (Exception e){
        
        
            e.printStackTrace();
        }finally {
        
        
            try {
        
        
                if (oos!=null){
        
        
                    oos.close();
                }
            }catch (Exception e){
        
        
                e.printStackTrace();
            }
        }
    }
}

读取基本数据类型数据

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamBasicTypeDemo {
        
        
    public static void main(String[] args) {
        
        
        ObjectInputStream ois=null;
        try {
        
        
            //ObjectInputStream是一个处理流，他最终还是要一个节点流（文件字节输入流）去关联数据源的，其中我们嵌套了一个缓存输入流
            ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/sxt5.txt")));
            //必须要按照写入的顺序读取数据
            System.out.println("int: "+ois.readInt());
            System.out.println("Double: "+ois.readDouble());
            System.out.println("char: "+ois.readChar());
            System.out.println("boolean: "+ois.readBoolean());
            System.out.println("String: "+ois.readUTF());

        }catch (Exception e){
        
        
            e.printStackTrace();
        }finally{
        
        
            try {
        
        
                if (ois!=null){
        
        
                    ois.close();
                }

            }catch (Exception e){
        
        
                e.printStackTrace();
            }
        }
    }
}

操作对象

将对象序列化到文件

ObjectOutputStream可以将一个内存中的java对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现Serializable序列化接口，否则会抛出异常。

创建对象

import java.io.Serializable;

public class Users implements Serializable {
        
        //Serializable标识接口，没有任何的抽象方法
    private int userid;
    private String username;
    private String userage;

    public Users(int userid, String username, String userage) {
        
        
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }

    public Users() {
        
        
    }

    public int getUserid() {
        
        
        return userid;
    }

    public void setUserid(int userid) {
        
        
        this.userid = userid;
    }

    public String getUsername() {
        
        
        return username;
    }

    public void setUsername(String username) {
        
        
        this.username = username;
    }

    public String getUserage() {
        
        
        return userage;
    }

    public void setUserage(String userage) {
        
        
        this.userage = userage;
    }
}

序列化对象

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamObjectTypeDemo {
        
        
    public static void main(String[] args) {
        
        
        ObjectOutputStream oos=null;
        try {
        
        
            //ObjectOutputStream是一个处理流对象，我们要把对象写出到外部的文当中，我们选择一个节点流对象，
            //我们一定要选择字节输出流对象，把java对象转换成一个字节的过程，我们称为序列化。
            //所以，我们选择的对象到字节的转换，所以是字节输出流：FileOutputStream
            oos =new ObjectOutputStream(new FileOutputStream("d:/sxt6.txt"));
            Users users=new Users(1,"oldlu","18");
            oos.writeObject(users);//writeObject(users);这个方法就是可以把一个序列化对象序列到外部，我们序列的是users对象
            oos.flush();
        }catch (Exception e){
        
        
            e.printStackTrace();
        }finally {
        
        
            try {
        
        
                if (oos!=null){
        
        
                    oos.close();
                }
            }catch (Exception e){
        
        
                e.printStackTrace();
            }
        }
    }
}

将对象反序列化到内存中

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamObjectTypeDemo {
        
        
    public static void main(String[] args) {
        
        
        ObjectInputStream ois=null;
        try {
        
        
            ois=new ObjectInputStream(new FileInputStream("d:/sxt6.txt"));
            Users users=(Users)ois.readObject();//readObject();方法将文件的序列化反序列化回来
            System.out.println(users.getUserid()+"\t"+users.getUsername()+"\t"+users.getUserage());
        }catch (Exception e){
        
        
            e.printStackTrace();
        }finally {
        
        
            try {
        
        
                if (ois!=null){
        
        
                    ois.close();
                }
            }catch (Exception e){
        
        
                e.printStackTrace();
            }
        }

    }
}

IO流-数据流、对象流(八)

IO流-数据流、对象流(八)

猜你喜欢