IO流：节点流和处理流详细归纳。

比眉伴天荒 2023-10-02 19:46 20阅读 0赞

**目录**

一、节点流和处理流

二、处理流

1、BufferedReader 字符流

2、BufferedWriter 字符流

3、利用二者进行文件拷贝

4、BufferedInputStream 字节流

5、BufferedOutputStream 字节流

三、ObjectOutputStream、ObjectInputStream

1、序列化和反序列化

2、 ObjectOutputStream

3、ObjectInputStream

4、注意事项

5、标准输入流和输出流

四、转换流

1、基本介绍

2、把 FileInputStream 转成 InputStreamReader

五、打印流

1、PrintWriter

2、PrintStream

六、Properties类

--------------------

## 一、节点流和处理流 ##

> **（1）节点流可以从一个特定的数据源读写数据**
> 
> ![37e2353629844387a75a36ae5f825a6d.png][]
> 
> **（2）处理流(也叫包装流）是“连接” 在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能**
> 
> ![93ab0b257bf545e5a40316cf9c1633d1.png][]
> 
> **（3）示意图**
> 
> ![fccd57476f6e43269859666f15786ebf.png][]
> 
> **（4）两者的区别**
> 
>  *  节点流是底层流/低级流,直接跟数据源相接
>  *  处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方  
>     便的方法来完成输入输出。
>  *  处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连
> 
> **（5）处理流的功能**
> 
>  *  性能的提高 : 主要以增加缓冲的方式来提高输入输出的效率
>  *  操作的便捷 ：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

--------------------

## 二、处理流 ##

>  *  BufferedReader 和 BufferedWriter 属于字符流，是按照字符来读取数据的
>  *  关闭流时, 只需要关闭外层流即可
>  *  BufferedinputStream是字节流，在创建BufferedlnputStream 时，会创建一个内部缓冲区数组
>  *  BufferedOutputStream是字节流， 实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统
> 
> ### 1、BufferedReader 字符流 ###
> 
>     public class BufferedReader_ {
>         public static void main(String[] args) throws IOException {
>             //文件路径
>             String filePath = "d:\\story.txt";
>     
>             //创建 BufferedReader 对象
>             BufferedReader bur = new BufferedReader(new FileReader(filePath));
>     
>             //读取
>             String line;//按行读取
>     
>             //当返回null时，表示文件读取完毕
>             while ((line = bur.readLine()) != null){
>     
>                 System.out.println(line);
>     
>             }
>     
>             //关闭流，这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭节点流
>             bufferedReader.close();
>         }
>     }
> 
> ### 2、BufferedWriter 字符流 ###
> 
>     public class BufferedWriter_ {
>         public static void main(String[] args) throws IOException {
>             //文件路径
>             String filePath = "d:\\ok.txt";
>     
>             //创建 BufferedWriter
>             //带true，表示追加
>             BufferedWriter bur = new BufferedWriter(new FileWriter(filePath,true));
>     
>             bufferedWriter.write("hello,继续努力");
>     
>             bufferedWriter.newLine();//插入一个和系统相关的换行符
>     
>             bufferedWriter.write("hello,继续努力");
>     
>             bufferedWriter.newLine();//插入一个和系统相关的换行符
>     
>             bufferedWriter.write("hello,继续努力");
>     
>     
>             //关闭外层流即可，传入的 new FileWriter(filePath),会在底层关闭
>             bufferedWriter.close();
>     
>     
>         }
>     }
> 
> ### 3、利用二者进行文件拷贝 ###
> 
>     public class BufferedCopy_ {
>         public static void main(String[] args) {
>             //文件路径
>             String srcFilePath = "d:\\story.txt";
>             String destFilePath = "d:\\story2.txt";
>     
>             //分别创建对象
>             BufferedReader br = null;
>             BufferedWriter bw = null;
>             
>             //按行读取
>             String line;
>     
>             try {
>                 //分别获取路径对象
>                 br = new BufferedReader(new FileReader(srcFilePath));
>                 bw = new BufferedWriter(new FileWriter(destFilePath));
>     
>                 //readLine() 按行获取
>                 while ((line = br.readLine()) != null){
>     
>                     //每读一行，就写入
>                     bw.write(line);
>     
>                     //插入一个换行符
>                     bw.newLine();
>     
>                 }
>             } catch (IOException e) {
>                 e.printStackTrace();
>             } finally {
>                 //两个流都要关闭
>                 try {
>                     if (br != null){
>                         br.close();
>                     }
>                     if (bw != null){
>                         bw.close();
>                     }
>                 } catch (IOException e) {
>                     e.printStackTrace();
>                 }
>             }
>         }
>     }
> 
> **注意：**
> 
>  *  BufferedReader 和 BufferedWriter 是按字符操作
>  *  不要去操作二进制文件\[视频，声音，doc，PDF 等\]，可能会造成文件损坏
> 
> ### 4、BufferedInputStream 字节流 ###
> 
> ![03929dfb2eb9497b84fe3109a542d247.jpeg][]
> 
> ### 5、BufferedOutputStream 字节流 ###
> 
> ![d51ee0296f6344b681a2eb2ca7bf8494.jpeg][]
> 
>     public class BufferedCopy02 {
>         public static void main(String[] args) {
>             //文件路径
>             String srcFilePath = "d:by.png";
>             String destFilePath = "d:newby.png";
>     
>             //创建对象
>             BufferedInputStream bis = null;
>             BufferedOutputStream bos = null;
>     
>             try {
>     
>                 //因为 FileInputStream 是 InputStream 的子类
>                 bis = new BufferedInputStream(new FileInputStream(srcFilePath));
>                 bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
>     
>                 //创建数组，以数组的方式读取和写入
>                 byte[] buff = new byte[1024];
>     
>                 //文件长度
>                 int readLen = 0;
>     
>                 //当返回-1 时，就表示文件读取完毕
>                 while ((readLen = bis.read(buff)) != -1){
>                     //边读取边写入
>                     bos.write(buff,0,readLen);
>     
>                 }
>     
>             } catch (IOException e) {
>                 e.printStackTrace();
>             } finally {
>                 //关闭流
>                 try {
>                     if (bis != null){
>                         bis.close();
>                     }
>                     if(bos != null){
>                         bos.close();
>                     }
>                 } catch (IOException e) {
>                     e.printStackTrace();
>                 }
>     
>             }
>         }
>     }

--------------------

## 三、ObjectOutputStream、ObjectInputStream ##

> ### 1、序列化和反序列化 ###
> 
>  *  序列化就是在保存数据时，保存数据的值和数据类型
>  *  反序列化就是在恢复数据时，恢复数据的值和数据类型
>  *  需要止某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：  
>     ①Serializable ②Externalizable
>  *  功能：提供了对基本类型或对象类型的序列化和反序列化的方法
>  *  ObjectOutputStream 提供序列化功能
> 
> ![f83942bbcd254c17b3c13f1b05fe719a.jpeg][]
> 
>  *  ObjectInputStream 提供反序列化功能
> 
> ![ee533966531e4e3fb2dea079f08a0660.jpeg][]
> 
> ###  ###
> 
> ### 2、 ObjectOutputStream ###
> 
>     public class ObjectOutStream_ {
>         public static void main(String[] args) throws Exception {
>     
>             //文件路径
>             String filePath = "d:\\data.txt";
>             
>             //创建对象
>             ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
>     
>             //序列化数据到 e:\data.dat
>             oos.writeInt(100); // int -> Integer (实现了 Serializable)
>     
>             oos.writeBoolean(true); //boolean -> Boolean (实现了 Serializable)
>     
>             oos.writeChar('a'); //char -> Character (实现了 Serializable)
>     
>             oos.writeDouble(9.5); //double -> Double (实现了 Serializable)
>     
>             oos.writeUTF("努力学习"); //String (实现了 Serializable)
>     
>             //保存一个dog对象
>             oos.writeObject(new Dog("小白",10));
>     
>             oos.close();
>             System.out.println("保存完毕");
>     
>         }
>     }
> 
> **注意：**序列化后，保存的文件格式，不是存文本的，而是按照它的格式来保存
> 
> ### 3、ObjectInputStream ###
> 
>     public class ObjectInputStream_ {
>         public static void main(String[] args) throws Exception{
>     
>             //指定反序列化的文件路径
>             String filePath = "d:\\data.txt";
>             
>             //创建对象
>             ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
>     
>             //读取（反序列化）的顺序需要和保存数据（序列化）的顺序一致，否则会报异常
>             System.out.println(ois.readInt());
>     
>             System.out.println(ois.readBoolean());
>     
>             System.out.println(ois.readChar());
>     
>             System.out.println(ois.readDouble());
>     
>             System.out.println(ois.readUTF());
>     
>             Object o = ois.readObject();
>             System.out.println("运行类型=" + o.getClass());
>             System.out.println("dog信息=" + o);
>     
>     
>             //特别重要的细节：需要我们将Dog类的定义，放到可以引用的位置
>             Dog dog = (Dog)o;
>             System.out.println(dog.getName());
>     
>     
>             //关闭流,关闭外层流即可，底层会关闭 FileInputStream 流
>             ois.close();
>         }
>     }
> 
> ### 4、注意事项 ###
> 
>  *  读写顺序要一致
>  *  要求实现序列化或反序列化对象，需要实现 Serializable接口
>  *  序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
>  *  序列化对象时, 默认将里面所有属性都进行序列化，但除了static关键字 或 transient关键字 修饰的成员
>  *  序列化对象时，要求里面属性的类型也需要实现序列化接口
>  *  序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
> 
> ### 5、标准输入流和输出流 ###
> 
>     public class InputAndOutput {
>         public static void main(String[] args) {
>     
>             //System 类的 public final static InputStream in null;
>             //System.in 编译类型  InputStream
>             //System.in 运行类型 BufferedInputStream
>             //表示标准输入 键盘
>             System.out.println(System.in.getClass());
>     
>             //System.out ->  public static final PrintStream out = null;
>             //编译类型 PrintStream
>             //运行类型 PrintStream
>             //表示标准输出 显示器
>             System.out.println(System.out.getClass());
>         }
>     }

--------------------

## 四、转换流 ##

> ### 1、基本介绍 ###
> 
>  *  InputStreamReader : Reader的子类, 可以将InputStream(字节流)包  
>     装成Reader(字符流)
>  *  OutputStreamWriter : Writer的子类，实现将OutputStream(字节流)  
>     包装成Writer(字符流)
>  *  当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文  
>     问题，所以建议将字节流转换成字符流
>  *  可以在使用时指定编码格式（比如 utf-8，gbk,gb2312等)
> 
> ### 2、把 FileInputStream 转成 InputStreamReader ###
> 
>     //指定编码gbk
>     InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
>     
>     //把InputStreamReader传入BufferedReader
>     BufferedReader br = new BufferedReader(isr);
>     
>     //读取
>     String s = br.readLine();
>     System.out.println("读取内容="+s);
>     
>     //关闭外层流
>     br.close();
> 
>     //创建流对象
>     OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\a.txt") , "gbk" );
>     
>     //写入
>     osw.write("hello，继续努力");
>     
>     //关闭
>     osw.close();

--------------------

## 五、打印流 ##

> ### 1、PrintWriter ###
> 
> ![68fdccf674e74e8ebd759f88b67ccf9d.png][]
> 
>     //PrintWriter pw= new PrintWriter(System.out);
>     
>     PrintWriter pw = new PrintWriter(new FileWriter("e:\\f2.txt"));
> 
> ### 2、PrintStream ###
> 
> ![3bc3d9267332485db8da6c094bdfcb16.png][]
> 
>     PrintStream out = System.out;
>     //在默认情况下，PrintStream输出数据的位置是标准输出，即显示器
> 
>     //因为print底层使用的是write,所以我们可以直接调用write进行打印/输出
>     out.write("努力学习".getBytes());
>     
>     out.close();
> 
>     //我们可以去修改打印流输出的位置/设备
>     System.setOut(new PrintStream("e:\\f1.txt"));
>     
>     System.out.println("努力学习");

--------------------

## 六、Properties类 ##

> **（1）专门用于读写配置文件的集合类** 
> 配置文件的格式 : 键=值
> 
> 注意 : 键值对不需要有空格，值不需要用引号引起来，默认类型是String
> 
> ip=192.168.0.13
> user=root
> pwd=12345
> 
> **（2）Properties的常见方法**
> 
> <table style="width:636px;"> 
> <thead> 
> <tr> 
> <th>方法</th> 
> <th style="width:381px;">功能</th> 
> </tr> 
> </thead> 
> <tbody> 
> <tr> 
> <td>load</td> 
> <td style="width:381px;">加载配置文件的健值对到Properties对象</td> 
> </tr> 
> <tr> 
> <td>list</td> 
> <td style="width:381px;">将数据显示到指定设备</td> 
> </tr> 
> <tr> 
> <td>getProperty(key)</td> 
> <td style="width:381px;">根据键获取值</td> 
> </tr> 
> <tr> 
> <td>setProperty(key , value)</td> 
> <td style="width:381px;">设健值对到Properties对象</td> 
> </tr> 
> <tr> 
> <td>store</td> 
> <td style="width:381px;"> 将Properties中的键值对存储到配置文件，在idea 中，保存信息到配置文件，如果含有中文，会存储为unicode码&nbsp; </td> 
> </tr> 
> </tbody> 
> </table>
> 
> //创建Properties对象
> Properties pr = new Properties();
> 
> //加载指定配置文件
> pr.load(new FileReader("src\\mysql.properties"));
> 
> //把key-value显示控制台
> pr.list(System.out);
> 
> //根据key获取对应的值
> String user = pr.getProperty("user");
> String pwd = pr.getProperty("pwd");
> 
> System.out.println("用户名="+user);
> System.out.println("密码是="+pwd);
> 
> //使用Properties类来创建配置文件,修改配置文件内容
> Properties pr = new Properties();
> 
> //创建
> //1.如果该文件没有key就是创建
> //2.如果该文件有key,就是修改
> pr.setProperty("charset","utf8");
> 
> pr.setProperty("user","汤姆");//注意保存时，是中文的unicode码值
> 
> pr.setProperty("pwd","888888");
> 
> //将key-value存储在文件中即可
> pr.store(new FileOutputStream("src\\mysql2.properties"),null);

[37e2353629844387a75a36ae5f825a6d.png]: https://img-blog.csdnimg.cn/37e2353629844387a75a36ae5f825a6d.png
[93ab0b257bf545e5a40316cf9c1633d1.png]: https://img-blog.csdnimg.cn/93ab0b257bf545e5a40316cf9c1633d1.png
[fccd57476f6e43269859666f15786ebf.png]: https://img-blog.csdnimg.cn/fccd57476f6e43269859666f15786ebf.png
[03929dfb2eb9497b84fe3109a542d247.jpeg]: https://img-blog.csdnimg.cn/03929dfb2eb9497b84fe3109a542d247.jpeg
[d51ee0296f6344b681a2eb2ca7bf8494.jpeg]: https://img-blog.csdnimg.cn/d51ee0296f6344b681a2eb2ca7bf8494.jpeg
[f83942bbcd254c17b3c13f1b05fe719a.jpeg]: https://img-blog.csdnimg.cn/f83942bbcd254c17b3c13f1b05fe719a.jpeg
[ee533966531e4e3fb2dea079f08a0660.jpeg]: https://img-blog.csdnimg.cn/ee533966531e4e3fb2dea079f08a0660.jpeg
[68fdccf674e74e8ebd759f88b67ccf9d.png]: https://img-blog.csdnimg.cn/68fdccf674e74e8ebd759f88b67ccf9d.png
[3bc3d9267332485db8da6c094bdfcb16.png]: https://img-blog.csdnimg.cn/3bc3d9267332485db8da6c094bdfcb16.png