day14【IO概述、字符流、字节流、属性操作】

Love The Way You Lie 2022-09-03 06:26 29阅读 0赞

# day14【IO概述、字符流、字节流、属性操作】 #

# 一、IO概述 #

## 1.1 IO流简介 ##

I（Input）O（Output）：中文翻译为输入输出，我们知道计算机的数据不管是软件、视频、音乐、游戏等最终都是存储在硬盘中的，当我们打开后，由CPU将硬盘中的数据读取到内存中来运行。这样一个过程就产生了I/O（输入/输出）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

> 水的流向我们成为水流，数据的流动成为数据流，我们简称为流；数据的流向根据流向的不同，我们分为输入（Input）流和输出（Output）流，简称输入输出流，或称IO流；

## 1.2 IO流的分类 ##

根据数据的流向分为：**输入流**和**输出流**。

*  **输入流** ：把数据从`其他设备`上读取到`内存`中的流。
 *  **输出流** ：把数据从`内存` 中写出到`其他设备`上的流。

根据操作数据单位的不同分为：**字节流**和**字符流**。

*  **字节流** ：以字节为单位，读写数据的流。
 *  **字符流** ：以字符为单位，读写数据的流。

在Java中描述流的底层父类：

<table> 
 <thead> 
  <tr> 
   <th align="center">抽象基类</th> 
   <th align="center"><strong>输入流</strong></th> 
   <th align="center">输出流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>字节流</strong></td> 
   <td align="center">字节输入流（InputStream）</td> 
   <td align="center">字节输出流（OutputStream）</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>字符流</strong></td> 
   <td align="center">字符输入流（Reader）</td> 
   <td align="center">字符输出流（Writer）</td> 
  </tr> 
 </tbody> 
</table>

> Java的IO流共涉及40多个类，都是从如下4个抽象基类派生的。由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

# 二、字节流 #

字节流有两个顶层接口父类，分别是字节输入流（InputStream）和字节输出流（OuputStream）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

## 2.1 字节输出流 ##

OutputStream是所有字节输出的顶层父类，该父类提供如下公共方法：

*  `public void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
 *  `public void flush()` ：刷新此输出流并强制任何缓冲的输出字节被写出。
 *  `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
 *  `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 *  `public abstract void write(int b)` ：将指定的字节输出流。

> tips：close方法，当完成流的操作时，必须调用此方法，释放系统资源。

## 2.2 FileOutputStream类 ##

OutputStream是抽象类，不可以实例化对象，我们使用它的子类FileOutputStream；FileOutputStream可以关联一个文件，用于将数据写出到文件。

FileOutputStream的构造方法如下：

*  `public FileOutputStream(File file)`：创建文件输出流以写入由指定的 File对象表示的文件。
 *  `public FileOutputStream(String name)`： 创建文件输出流以指定的名称写入文件。

> tips：当创建一个流对象时，需要指定一个文件路径，如果该文件以及存在则会清空文件中的数据，如果不存在则创建一个新的文件；

示例代码：

package com.dfbz.demo01;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileOutputStream fos1 = new FileOutputStream(file);
    
            // 使用文件名称创建流对象
            FileOutputStream fos2 = new FileOutputStream("b.txt");
        }
    }

### 2.1.1 写出字节 ###

1.  **写出字节**：`write(int b)` 方法，每次可以写出一个字节数据，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("abc.txt");
            // 写出数据
            fos.write(97); // 写出第1个字节(a)
            fos.write(98); // 写出第2个字节(b)
            fos.write(99); // 写出第3个字节(c)
            // 关闭资源
            fos.close();
        }
    }

> tips：虽然参数为int类型四个字节，但是只会保留一个字节的信息写出

1.  **写出字节数组**：`write(byte[] b)`，每次可以写出数组中的数据，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象(如果有这个文件将清空这个文件的数据)
            FileOutputStream fos = new FileOutputStream("abc.txt");
            // 字符串转换为字节数组
            byte[] b = "东方标准".getBytes();
            // 写出字节数组数据
            fos.write(b);
            // 关闭资源
            fos.close();
        }
    }

1.  **写出指定长度字节数组**：`write(byte[] b, int off, int len)` ,每次写出从off索引开始，len个字节，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("abc.txt");
            // 字符串转换为字节数组
            byte[] b = "abcde".getBytes();
            // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
            fos.write(b,2,2);
            // 关闭资源
            fos.close();
        }
    }

### 2.1.2 数据追加续写 ###

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

*  `public FileOutputStream(File file, boolean append)`： 创建文件输出流以写入由指定的 File对象表示的文件。
 *  `public FileOutputStream(String name, boolean append)`： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，`true` 表示追加数据，`false` 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo05 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("abc.txt",true);
            // 字符串转换为字节数组
            byte[] b = "abcde".getBytes();
            // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
            fos.write(b);
            // 关闭资源
            fos.close();
        }
    }

### 2.2.3 写出换行 ###

Windows系统里，换行符号是`\r\n` 。以指定是否追加续写了，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo06 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("abc.txt");
            // 定义字节数组
            byte[] words = { 97, 98, 99, 100, 101};
            // 遍历数组
            for (int i = 0; i < words.length; i++) { 
                // 写出一个字节
                fos.write(words[i]);
                // 写出一个换行, 换行符号转成数组写出
                fos.write("\r\n".getBytes());
            }
            // 关闭资源
            fos.close();
        }
    }

>  *  回车符`\r`和换行符`\n` ：
>     
>      *  回车符：回到一行的开头（return）。
>      *  换行符：下一行（newline）。
>  *  系统中的换行：
>     
>      *  Windows系统里，每行结尾是 `回车+换行` ，即`\r\n`；
>      *  Unix系统里，每行结尾只有 `换行` ，即`\n`；
>      *  Mac系统里，每行结尾是 `回车` ，即`\r`。从 Mac OS X开始与Linux统一。

## 2.3 字节输入流 ##

`java.io.InputStream`抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

*  `public void close()` ：关闭此输入流并释放与此流相关联的任何系统资源。
 *  `public abstract int read()`： 从输入流读取数据的下一个字节。
 *  `public int read(byte[] b)`： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

> tips：close方法，当完成流的操作时，必须调用此方法，释放系统资源。

## 2.4 FileInputStream类 ##

`java.io.FileInputStream`类是文件输入流，从文件中读取字节。

### 2.4.1 构造方法 ###

*  `FileInputStream(File file)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
 *  `FileInputStream(String name)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出`FileNotFoundException` 。

*  构造举例，代码如下：

package com.dfbz.demo02;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileInputStream fos = new FileInputStream(file);
    
            // 使用文件名称创建流对象
            FileInputStream fos2 = new FileInputStream("b.txt");
        }
    }

### 2.4.2 读取字节数据 ###

将abc.txt文件的内容改为`abcde`

1.  **读取字节**：`read`方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回`-1`，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileInputStream fis = new FileInputStream("abc.txt");
            // 读取数据，返回一个字节
            int read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            // 读取到末尾,返回-1
            read = fis.read();
            System.out.println(read);
            // 再读还是-1
            read = fis.read();
            System.out.println(read);
            // 关闭资源
            fis.close();
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

循环改进读取方式，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileInputStream fis = new FileInputStream("abc.txt");
            // 定义变量，保存数据
            int b;
            // 循环读取,只要读取的不是-1就继续读
            while ((b = fis.read()) != -1) { 
                System.out.println((char) b);
            }
            // 关闭资源
            fis.close();
        }
    }

> tips：虽然读取了一个字节，但是会自动提升为int类型。

1.  **使用字节数组读取**：`read(byte[] b)`，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回`-1` ，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象.
            FileInputStream fis = new FileInputStream("abc.txt"); // 文件中为abcde
            // 定义变量，作为有效个数
            int len ;
            // 定义字节数组，作为装字节数据的容器
            byte[] b = new byte[2];
            // 循环读取
            while ((len = fis.read(b)) != -1) { 
                // 每次读取后,把数组变成字符串打印
                System.out.println(new String(b));
            }
            // 关闭资源
            fis.close();
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

发现d出现了两次，这是由于最后一次读取时，只读取到了一个有效字节“e”，替换了原数组的0下标的“c”，图解分析如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

我们在转换的时候不能全部转换，而是只转换有效的字节，所以要通过`len`（实际读取到的字节个数） ，获取有效的字节，来决定到底转换多少个字节；

*  示例代码：

package com.dfbz.demo02;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo05 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象.
            FileInputStream fis = new FileInputStream("abc.txt"); // 文件中为abcde
            // 定义变量，作为有效个数
            int len;
            // 定义字节数组，作为装字节数据的容器
            byte[] b = new byte[2];
            // 循环读取
            while ((len = fis.read(b)) != -1) { 
                // 每次读取后,把数组的有效字节部分，变成字符串打印
                System.out.println(new String(b, 0, len));// len 每次读取的有效字节个数
            }
            // 关闭资源
            fis.close();
        }
    }

## 2.5 字节流练习 ##

FileOutputStream 主要按照字节方式写文件，例如：我们做文件的复制，首先读取文件，读取后在将该文件另写一份保存到磁盘上，这就完成了备份

*  示例代码：

package com.dfbz.demo02;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo06 { 
        public static void main(String[] args) throws IOException { 
            // 1.创建输入流,用于读取文件
            FileInputStream fis = new FileInputStream("D:\\apache-tomcat-8.0.43.zip");
            // 2. 创建输出流,用于写出文件
            FileOutputStream fos = new FileOutputStream("D:\\apache-tomcat-8.0.43_bak.zip");
    
            // 3. 定义数组大小(一次性读取多少个字节)
            byte[] b = new byte[1024];
    
            // 4. 定义变量,接受每次实际读取到的数据长度
            int len;
    
            // 5. 循环读取并写出
            while ((len = fis.read(b))!=-1) { 
                // 将数据数组中的数据写入关联的指定文件
                fos.write(b, 0 , len);
            }
    
            // 6. 释放资源
            fos.close();
            fis.close();
        }
    }

# 三、字符流 #

计算机都是按照字节进行存储的，我们之前学习过编码表，通过编码表可以将字节转换为对应的字符，但是世界上有非常多的编码表，不同的编码表规定的单个字符所占用的字节可能都不一样，且一个字符都是由多个字节组成的，为此我们不能再基于字节的操作单位来操作文本文件了，因为这样太过麻烦，我们希望基于字符来操作文件，一次操作读取一个“字符”而不是一个“字节”，这样在操作文本文件时非常便捷；

## 3.1 字符输入流 ##

`java.io.Reader`抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

*  `public void close()` ：关闭此流并释放与此流相关联的任何系统资源。
 *  `public int read()`： 从输入流读取一个字符。
 *  `public int read(char[] cbuf)`： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

## 3.2 FileReader类 ##

`java.io.FileReader`类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

> tips：
> 
> 1.  字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。idea中默认是UTF-8
> 2.  字节缓冲区：一个字节数组，用来临时存储字节数据。

### 3.2.1 构造方法 ###

*  `FileReader(File file)`： 创建一个新的 FileReader ，给定要读取的File对象。
 *  `FileReader(String fileName)`： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

*  构造举例，代码如下：

package com.dfbz.demo01;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileReader fr = new FileReader(file);
    
            // 使用文件名称创建流对象
            FileReader fr2 = new FileReader("b.txt");
        }
    }

### 3.2.2 读取字符数据 ###

1.  **读取字符**：`read`方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回`-1`，循环读取，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileReader fr = new FileReader("read.txt");
            // 定义变量，保存数据
            int b;
            // 循环读取
            while ((b = fr.read()) != -1) { 
                System.out.println((char) b);
            }
            // 关闭资源
            fr.close();
        }
    }
    输出结果：
    我
    是
    中
    国
    人

> tips：虽然读取了一个字符，但是会自动提升为int类型。

1.  **使用字符数组读取**：`read(char[] cbuf)`，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回`-1` ，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileReader fr = new FileReader("read.txt");
            // 定义变量，保存有效字符个数
            int len;
            // 定义字符数组，作为装字符数据的容器
            char[] cbuf = new char[2];
            // 循环读取
            while ((len = fr.read(cbuf)) != -1) { 
                System.out.println(new String(cbuf));
            }
            // 关闭资源
            fr.close();
        }
    }
    
    输出结果：
    我是
    中国
    国人

获取有效的字符改进，代码使用演示：

package com.dfbz.demo01;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileReader fr = new FileReader("read.txt");
            // 定义变量，保存有效字符个数
            int len;
            // 定义字符数组，作为装字符数据的容器
            char[] cbuf = new char[2];
            // 循环读取
            while ((len = fr.read(cbuf)) != -1) { 
                System.out.println(new String(cbuf, 0, len));
            }
            // 关闭资源
            fr.close();
        }
    }
    
    
    输出结果：
    我是
    中国
    人

## 3.3 字符输出流 ##

`java.io.Writer`抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

*  `void write(int c)` 写入单个字符。
 *  `void write(char[] cbuf)`写入字符数组。
 *  `abstract void write(char[] cbuf, int off, int len)`写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
 *  `void write(String str)`写入字符串。
 *  `void write(String str, int off, int len)` 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
 *  `void flush()`刷新该流的缓冲。
 *  `void close()` 关闭此流，但要先刷新它。

## 3.4 FileWriter类 ##

`java.io.FileWriter`类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

### 3.4.1 构造方法 ###

*  `FileWriter(File file)`： 创建一个新的 FileWriter，给定要读取的File对象。
 *  `FileWriter(String fileName)`： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

*  构造举例，代码如下：

package com.dfbz.demo02;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws IOException { 
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileWriter fw = new FileWriter(file);
    
            // 使用文件名称创建流对象
            FileWriter fw2 = new FileWriter("b.txt");
        }
    }

### 3.4.2 基本写出数据 ###

**写出字符**：`write(int b)` 方法，每次可以写出一个字符数据，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileWriter fw = new FileWriter("fw.txt");
            // 写出数据
            fw.write(97); // 写出第1个字符
            fw.write('b'); // 写出第2个字符
            fw.write('C'); // 写出第3个字符
            fw.write(22909); // 写出第4个字符，中文编码表中22909对应一个汉字"好"。
    
          	/* 【注意】关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区，并未保存到文件。 */
             fw.close();
        }
    }
    
    输出结果：
    abC好

> tips：
> 
> 1.  虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
> 2.  未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

### 3.4.3 关闭和刷新 ###

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要`flush` 方法了。

*  `flush` ：刷新缓冲区，流对象可以继续使用。
 *  `close`：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileWriter fw = new FileWriter("fw.txt");
            // 写出数据，通过flush
            fw.write('刷'); // 写出第1个字符
            fw.flush();
            fw.write('新'); // 继续写出第2个字符，写出成功
            fw.flush();
    
            // 写出数据，通过close
            fw.write('关'); // 写出第1个字符
            fw.close();
            fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
            fw.close();
        }
    }

> tips：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

### 3.4.4 写出其他数据 ###

1.  **写出字符数组** ：`write(char[] cbuf)` 和 `write(char[] cbuf, int off, int len)` ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象
            FileWriter fw = new FileWriter("fw.txt");
            // 字符串转换为字节数组
            char[] chars = "我是中国人".toCharArray();
    
            // 写出字符数组
            fw.write(chars); // 我是中国人
    
            // 写出从索引2开始，2个字节。索引2是'中'，两个字节，也就是'中国'。
            fw.write(chars,2,2); // 中国
    
            // 关闭资源
            fw.close();
        }
    }

1.  **写出字符串**：`write(String str)` 和 `write(String str, int off, int len)` ，每次可以写出字符串中的数据，更为方便，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo05 { 
        public static void main(String[] args) throws IOException {         // 使用文件名称创建流对象
            FileWriter fw = new FileWriter("fw.txt");            // 字符串
            String msg = "我是中国人";                // 写出字符数组
            fw.write(msg); //我是中国人 // 写出从索引2开始，2个字节。索引2是'中'，两个字节，也就是'中国'。
            fw.write(msg, 2, 2);    // 中国
            // 关闭资源
            fw.close();
        }
    }

1.  **续写和换行**：操作类似于FileOutputStream。

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo06 { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象，可以续写数据
            FileWriter fw = new FileWriter("fw.txt", true);
            // 写出字符串
            fw.write("我是");
            // 写出换行
            fw.write("\r\n");
            // 写出字符串
            fw.write("中国人");
            // 关闭资源
            fw.close();
        }
    }
    
    输出结果:
    我是
    中国人

> tips：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

# 四、IO异常的处理 #

## 4.1 JDK7前处理 ##

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用`try...catch...finally` 代码块，处理异常部分，代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo07 { 
        public static void main(String[] args) { 
            // 声明变量
            FileWriter fw = null;
            try { 
                //创建流对象
                fw = new FileWriter("fw.txt");
                // 写出数据
                fw.write("我是中国人"); //我是中国人
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                // 不管是否出现异常都需要关闭流,释放资源
                try { 
                    if (fw != null) { 
                        fw.close();
                    }
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

## 4.2 JDK7的处理 ##

还可以使用JDK7优化后的`try-with-resource` 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

try (创建流对象语句，如果多个,使用';'隔开) { 
    	// 读写数据
    } catch (IOException e) { 
    	e.printStackTrace();
    }

代码使用演示：

package com.dfbz.demo02;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo08 { 
        public static void main(String[] args) { 
            // 创建流对象
            try (FileWriter fw = new FileWriter("fw.txt");) { 
                // 写出数据
                fw.write("我是中国人"); //我是中国人
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

# 五、属性集 #

## 5.1 概述 ##

`java.util.Properties` 继承于`Hashtable` ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，`System.getProperties` 方法就是返回一个`Properties`对象。

## 5.2 Properties类 ##

### 5.2.1 构造方法 ###

*  `public Properties()` :创建一个空的属性列表。

### 5.2.2 基本的存储方法 ###

*  `public Object setProperty(String key, String value)` ： 保存一对属性。
 *  `public String getProperty(String key)` ：使用此属性列表中指定的键搜索属性值。
 *  `public Set<String> stringPropertyNames()` ：所有键的名称的集合。

package com.dfbz.demo03;
    
    import java.io.FileNotFoundException;
    import java.util.Properties;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    package com.dfbz.demo03;
    
    import java.io.FileNotFoundException;
    import java.util.Properties;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 创建属性集对象
            Properties properties = new Properties();
            // 添加键值对元素
            properties.setProperty("filename", "a.txt");
            properties.setProperty("length", "209385038");
            properties.setProperty("location", "D:\\a.txt");
            // 打印属性集对象
            System.out.println(properties);
            // 通过键,获取属性值
            System.out.println(properties.getProperty("filename"));
            System.out.println(properties.getProperty("length"));
            System.out.println(properties.getProperty("location"));
    
            // 遍历属性集,获取所有键的集合
            Set<String> strings = properties.stringPropertyNames();
            // 打印键值对
            for (String key : strings) { 
                System.out.println(key + " -- " + properties.getProperty(key));
            }
        }
    }
    
    输出结果：
    { filename=a.txt, length=209385038, location=D:\a.txt}
    a.txt
    209385038
    D:\a.txt
    filename -- a.txt
    length -- 209385038
    location -- D:\a.txt

### 5.2.3 与流相关的方法 ###

*  `public void load(InputStream inStream)`： 从字节输入流中读取键值对。

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

filename=a.txt
    length=209385038
    location=D:\a.txt

加载代码演示：

package com.dfbz.demo03;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 创建属性集对象
            Properties prop = new Properties();
            // 加载文本中信息到属性集
            prop.load(new FileInputStream("prop.txt"));
            // 遍历集合并打印
            Set<String> strings = prop.stringPropertyNames();
            for (String key : strings ) { 
                System.out.println(key+" -- "+prop.getProperty(key));
            }
        }
    }
    
    输出结果：
    filename -- a.txt
    length -- 209385038
    location -- D:\a.txt

> tips：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

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

**上一篇**：[day13【线程等待、状态、线程池、File类】][day13_File]

**下一篇**：[day15【转换流、缓冲流、序列流、打印流】][day15]

**目录**：【JavaSE零基础系列教程目录】

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

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/ae8b3a7b5005411d9882a1a174cfb20b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/662825cb882c4c9da3ce5ffab0d590f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/963f4b89c80d41e48bd8724abc3c6c72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/b7a9e1604f0f47adbfc77abda9aa063b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/56ff78822d324792b57b1a5c4a5531b5.png
[day13_File]: https://blog.csdn.net/Bb15070047748/article/details/119424448?spm=1001.2014.3001.5501
[day15]: https://blog.csdn.net/Bb15070047748/article/details/119451777