Java——IO流（二）-（6/7）：其他流-数据流（DataOutputStream、DatalnputStream）、序列化流（ObjectOutputStream......）

目录

数据流

DataOutputStream(数据输出流)

实例演示(1)

DatalnputStream(数据输入流)

实例演示(2)

序列化流

序列化

实例演示(3)

反序列化

实例演示(4)

---

数据流

DataOutputStream(数据输出流)

• 允许把数据和其类型一并写出去。

构造器	说明
public DataOutputStream(OutputStream out)	创建新数据输出流包装基础的字节输出流

方法	说明
public final void writeByte(int v) throws IOException	将byte类型的数据写入基础的字节输出流
public final void writeInt(int v) throws IOException	将int类型的数据写入基础的字节输出流
public final void writeDouble(Double v) throws IOException	将double类型的数据写入基础的字节输出流
public final void writeUTF(String str) throws IOException	将字符串数据以UTF-8编码成字节写入基础的字节输出流
public void write(int/byte[]/byte[]—部分)	支持写字节数据出去

实例演示(1)

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

public class DataOutputStreamTest {
    public static void main(String[] args) {
        try(
                //1.创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("HelloWorld/src/testFile4.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("柚子");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

DatalnputStream(数据输入流)

• 用于读取数据输出流写出去的数据。

构造器	说明
public DataInputStream(InputStream is)	创建新数据输入流包装基础的字节输入流

方法	说明
public final byte readByte() throws IOException	读取字节数据返回
public final int readInt() throws IOException	读取int类型的数据返回
public final double readDouble() throws IOException	读取double类型的数据返回
public final String readUTF() throws IOException	读取字符串数（UTF-8）据返回
public int readInt()/read(byte[])	支持读字节数据进来

实例演示(2)

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

public class DataInputStreamTest {
    public static void main(String[] args) {
        try(
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("HelloWorld/src/testFile4.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        }catch (Exception e){

        }
    }
}

运行结果：

序列化流

• 对象序列化：把Java对象写入到文件中去
• 对象反序列化：把文件里的Java对象读出来

序列化

ObjectOutputStream(对象字节输出流)

• 可以把Java对象进行序列化：把Java对象存入到文件中去。

构造器	说明
public ObjectOutputStream(OutputStream out)	创建对象字节输出流，包装基础的字节输出流

方法	说明
public final void writeObject(Object o) throws IOException	把对象写出去

注意：对象如果要参与序列化，必须实现序列化接口（java.io.Serializable）

实例演示(3)

定义一个测试用的User类：

import java.io.Serializable;

//注意：如果对象需要序列化，必须实现序列化接口！
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    private String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

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

public class ObjectOutputStreamTest {
    public static void main(String[] args) {
        try(
                //2.创建一个对象字节输出流包装原始的字节输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("HelloWorld/src/testFile5.txt"))
                ){
            //1.创建一个Java对象
            User u = new User("admin","张三",32,"66668888");
            //3.序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

反序列化

ObjectInputStream(对象字节输入流)

• 可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中来。

构造器	说明
public ObjectInputStream(InputStream is)	创建对象字节输入流，包装基础的字节输入流

方法	说明
public final Object readObject()	把存储在文件中的Java对象读出来

实例演示(4)

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

public class ObjectInputStreamTest {
    public static void main(String[] args) {
        try(
                //1.创建一个对象字节输入流管道，包装低级的字节输入流与源文件接通
                ObjectInputStream ois =
                        new ObjectInputStream(new FileInputStream("HelloWorld/src/testFile5.txt"));
                ){
            User u = (User) ois.readObject();
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

指定成员变量不参与序列化：

如果要一次序列化多个对象：

用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可

注意：ArrayList集合已经实现了序列化接口！

---

END

---

学习自：黑马程序员——Java课程