Java中的IO流详解（二）

von Libniz

已于 2022-08-08 11:29:04 修改

阅读量181

点赞数

分类专栏： Java 文章标签： java jvm 算法

于 2022-08-08 11:28:03 首次发布

本文链接：https://blog.csdn.net/demon_lmman/article/details/126223542

版权

Java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

1.1 PrintStream

java.io.PrintStream类主要用于更加方便地打印各种数据内容。
在这里插入图片描述
案例：不断地提示用户输入要发送的内容，若发送的内容是"bye"则聊天结束，否则将用户输入的内容写入到文件d:/a.txt中。要求使用BufferedReader类来读取键盘的输入，System.in代表键盘输入要求使用PrintStream类负责将数据写入文件。

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class PrintStreamTest {

    public static void main(String[] args) {

        // 由手册可知：构造方法需要的是Reader类型的引用，但Reader类是个抽象类，实参只能传递子类的对象  字符流
        // 由手册可知： System.in代表键盘输入， 而且是InputStream类型的 字节流
        BufferedReader br = null;
        PrintStream ps = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            ps = new PrintStream(new FileOutputStream("d:/a.txt", true));

            // 声明一个boolean类型的变量作为发送方的代表
            boolean flag = true;

            while(true) {
                // 1.提示用户输入要发送的聊天内容并使用变量记录
                System.out.println("请" + (flag? "张三": "李四") + "输入要发送的聊天内容：");
                String str = br.readLine();
                // 2.判断用户输入的内容是否为"bye"，若是则聊天结束
                if ("bye".equals(str)) {
                    System.out.println("聊天结束！");
                    break;
                }
                // 3.若不是则将用户输入的内容写入到文件d:/a.txt中
                //else {
                // 获取当前系统时间并调整格式
                Date d1 = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                ps.println(sdf.format(d1) + (flag?" 张三说：":" 李四说：") + str);
                //}
                flag = !flag;
            }
            ps.println(); // 写入空行 与之前的聊天记录隔开
            ps.println();
            ps.println();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭流对象并释放有关的资源
            if (null != ps) {
                ps.close();
            }
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.2 OutputStreamWriter

java.io.OutputStreamWriter类主要用于实现从字符流到字节流的转换。
在这里插入图片描述

1.3 InputStreamReader

java.io.InputStreamReader类主要用于实现从字节流到字符流的转换。
在这里插入图片描述

1.4 DataOutputStream

java.io.DataOutputStream类主要用于以适当的方式将基本数据类型写入输出流中。
在这里插入图片描述

public class DataOutputStreamTest {

    public static void main(String[] args) {
        DataOutputStream dos = null;

        try {
            // 1.创建DataOutputStream类型的对象与d:/a.txt文件关联
            dos = new DataOutputStream(new FileOutputStream("d:/a.txt"));
            // 2.准备一个整数数据66并写入输出流
            // 66: 0000 0000 ... 0100 0010    =>   B
            int num = 66;
            //dos.writeInt(num);  // 写入4个字节
            dos.write(num);       // 写入1个字节
            System.out.println("写入数据成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流对象并释放有关的资源
            if (null != dos) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.5 DataInputStream类

java.io.DataInputStream类主要用于从输入流中读取基本数据类型的数据。
在这里插入图片描述

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

public class DataInputStreamTest {

    public static void main(String[] args) {
        DataInputStream dis = null;

        try {
            // 1.创建DataInputStream类型的对象与d:/a.txt文件关联
            dis = new DataInputStream(new FileInputStream("d:/a.txt"));
            // 2.从输入流中读取一个整数并打印
            // int res = dis.readInt(); // 读取4个字节
            int res = dis.read();      // 读取1个字节
            System.out.println("读取到的整数数据是：" + res); // 66
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流对象并释放有关的资源
            if (null != dis) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.6 ObjectOutputStream类（重点）

java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中。
只能将支持 java.io.Serializable 接口的对象写入流中。
类通过实现 java.io.Serializable 接口以启用其序列化功能。
所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程。

在这里插入图片描述
示例：将User类对象序列化。

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

public class ObjectOutputStreamTest {

    public static void main(String[] args) {
        ObjectOutputStream oos = null;

        try {
            // 1.创建ObjectOutputStream类型的对象与d:/a.txt文件关联
            oos = new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
            // 2.准备一个User类型的对象并初始化
            User user = new User("Bob", "123456", "13511258688");
            // 3.将整个User类型的对象写入输出流
            oos.writeObject(user);
            System.out.println("写入对象成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭流对象并释放有关的资源
            if (null != oos) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

user类：

public class User implements java.io.Serializable {
    private static final long serialVersionUID = -5814716593800822421L;

    private String userName;  // 用户名
    private String password;  // 密码
    private transient String phoneNum;  // 手机号  表示该成员变量不参与序列化操作

    public User() {
    }

    public User(String userName, String password, String phoneNum) {
        this.userName = userName;
        this.password = password;
        this.phoneNum = phoneNum;
    }

    public String getUserName() {
        return userName;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", phoneNum='" + phoneNum + '\'' +
                '}';
    }
}

1.7 ObjectInputStream类（重点）

java.io.ObjectInputStream类主要用于从输入流中一次性将对象整体读取出来。
所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程。
在这里插入图片描述
（1）序列化版本号
序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidCastException)。
（2）transient关键字
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
（3)写入多个对象
希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一次readObject方法就可以将整个集合的数据读取出来，从而避免了通过返回值进行是否达到文件末尾的判断。
（4）示例代码

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

public class ObjectInputStreamTest {

    public static void main(String[] args) {
        ObjectInputStream ois = null;

        try {
            // 1.创建ObjectInputStream类型的对象与d:/a.txt文件关联
            ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
            // 2.从输入流中读取一个对象并打印
            Object obj = ois.readObject();
            System.out.println("读取到的对象是：" + obj); // qidian 123456 13511258688  null
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流对象并释放有关的资源
            if (null != ois) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.8 RandomAccessFile

java.io.RandomAccessFile类主要支持对随机访问文件的读写操作。
在这里插入图片描述
示例代码

public class RandomAccessFileTest {

    public static void main(String[] args) {
        RandomAccessFile raf = null;

        try {
            // 1.创建RandomAccessFile类型的对象与d:/a.txt文件关联
            raf = new RandomAccessFile("d:/a.txt", "rw");
            // 2.对文件内容进行随机读写操作
            // 设置距离文件开头位置的偏移量，从文件开头位置向后偏移3个字节    aellhello
            raf.seek(3);
            int res = raf.read();
            System.out.println("读取到的单个字符是：" + (char)res); // a l
            res = raf.read();
            System.out.println("读取到的单个字符是：" + (char)res); // h 指向了e
            raf.write('2'); // 执行该行代码后覆盖了字符'e'
            System.out.println("写入数据成功！");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流对象并释放有关的资源
            if (null != raf) {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

von Libniz

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java中的IO流详解（二）

在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidCastException)。希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一次readObject方法就可以将整个集合的数据读取出来，从而避免了通过返回值进行是否达到文件末尾的判断。......
复制链接

扫一扫

专栏目录