Java基础：字节流、字符流

迷南。 2024-03-30 08:52 31阅读 0赞

## **第一章 `IO`概述** ##

### **1.1 什么是`IO`** ###

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了`ctrl+s`，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入`input`和输出`output`，即流向内存是输入流，流出内存的输出流。

`Java`中`I/O`操作主要是指使用`java.io`包下的内容，进行输入、输出操作。**输入**也叫做**读取**数据，**输出**也叫做作**写出**数据。

### **1.2 `IO`的分类** ###

*  根据数据的流向分为：**输入流**和**输出流**。
    
     *  **输入流** ：把数据从 其他设备 上读取到 内存 中的流。
     *  **输出流** ：把数据从 内存 中写出到 其他设备 上的流。
 *  格局数据的类型分为：**字节流**和**字符流**。
    
     *  **字节流** ：以字节为单位，读写数据的流。
     *  **字符流** ：以字符为单位，读写数据的流。

### **1.3 `IO`的流向说明图解** ###

![在这里插入图片描述][8f44361ef9fa454db5e34a03fef6e574.png_pic_center]

### **1.4 顶级父类们** ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th><strong>输入流</strong></th> 
   <th><strong>输出流</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字节流</td> 
   <td>字节输入流<code>InputStream</code></td> 
   <td>字节输出流<code>OutputStream</code></td> 
  </tr> 
  <tr> 
   <td>字符流</td> 
   <td>字符输入流<code>Reader</code></td> 
   <td>字符输出流<code>Writer</code></td> 
  </tr> 
 </tbody> 
</table>

## **第二章 字节流** ##

### **2.1 一切皆为字节** ###

一切文件数据（文本、图片、视频等）在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

### **2.2 字节输出流【`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)`：将指定的字节输出流。

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

### **2.3 `FileOutputStream`类** ###

`OutputStream`有很多子类，我们从最简单的一个子类开始。

`java.io.FileOutputStream`类是文件输出流，用于将数据写出到文件。

#### **构造方法** ####

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

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor {
        
        public static void main(String[] args) throws FileNotFoundException {
        
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileOutputStream fos = new FileOutputStream(file);
    
            // 使用文件名称创建流对象
            FileOutputStream fos2 = new FileOutputStream("b.txt");
        }
    }

#### **写出字节数据** ####

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

package com.dcxuexi.java23;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title FOSWrite
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 17:42
     * @Version 1.0.0
     */
    public class FOSWrite {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream.txt");
            // 写出数据
            fileOutputStream.write(97); // 写出第1个字节
            fileOutputStream.write(98); // 写出第2个字节
            fileOutputStream.write(99); // 写出第3个字节
            // 关闭资源
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][e1a08b489b3c466e830006c9fa2a43d5.png_pic_center]

> 小贴士：
> 
>  *  虽然参数为`int`类型四个字节，但是只会保留一个字节的信息写出。
>  *  流操作完毕后，必须释放系统资源，调用`close`方法，千万记得。

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

package com.dcxuexi.java23;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title FOSWrite02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 17:49
     * @Version 1.0.0
     */
    public class FOSWrite02 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream02.txt");
            // 字符串转换为字节数组
            byte[] b = "我爱北京天安门".getBytes();
            // 写出字节数组数据
            fileOutputStream.write(b);
            // 关闭资源
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][158494311c004588bf93cc98b83252b1.png_pic_center]

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

package com.dcxuexi.java23;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title FOSWrite03
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 17:54
     * @Version 1.0.0
     */
    public class FOSWrite03 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream03.txt");
            // 字符串转换为字节数组
            byte[] bytes = "abcdefg".getBytes();
            // 写出从索引2开始，2个字节。索引2是c，三个字节，也就是cde。
            fileOutputStream.write(bytes,2,3);
            // 关闭资源
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][6aca79b6ff06474382aeb24d4ee96af7.png_pic_center]

**数据追加续写**

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

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

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

package com.dcxuexi.java23;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title FOSWrite04
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 17:59
     * @Version 1.0.0
     */
    public class FOSWrite04 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream03.txt",true);
            // 字符串转换为字节数组
            byte[] bytes = "hijklmn".getBytes();
            // 追加写出字节数组数据
            fileOutputStream.write(bytes);
            // 关闭资源
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][cb549b92135a441ab29c730acc609d67.png_pic_center]

#### **写出换行** ####

`Windows`系统里，换行符号是`\r\n`。代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title FOSWrite05
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 18:04
     * @Version 1.0.0
     */
    public class FOSWrite05 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream05.txt");
            // 定义字节数组
            byte[] bytes = "abcdef".getBytes();
            // 遍历数组
            for (int i = 0; i < bytes.length; i++) {
        
                fileOutputStream.write(bytes[i]);
                fileOutputStream.write("\r\n".getBytes());
            }
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][adea72572f49410c85a17c6aab58beab.png_pic_center]

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

### **2.4 字节输入流【`InputStream`】** ###

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

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

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

### **2.5 `FileInputStream`类** ###

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

#### **构造方法** ####

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

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

构造举例，代码如下：

public class FileOutputStreamConstructor  {
        
        public static void main(String[] args) throws FileNotFoundException {
        
            // 使用File对象创建流对象
            File file = new File("a.txt");
            FileOutputStream fos = new FileOutputStream(file);
    
            // 使用文件名称创建流对象
            FileOutputStream fos2 = new FileOutputStream("b.txt");
        }
    }

#### **读取字节数据** ####

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

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    /***
     * @Title FISRead
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 18:26
     * @Version 1.0.0
     */
    public class FISRead {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");
            // 读取数据，返回一个字节
            int read = fileInputStream.read();
            System.out.println((char) read);
            read = fileInputStream.read();
            System.out.println((char) read);
            read = fileInputStream.read();
            System.out.println((char) read);
            read = fileInputStream.read();
            System.out.println((char) read);
            read = fileInputStream.read();
            System.out.println((char) read);
            // 读取到末尾,返回-1
            read = fileInputStream.read();
            System.out.println( read);
            // 关闭资源
            fileInputStream.close();
        }
    }

![在这里插入图片描述][dcaaee6a3d414afd8cba6ced11941525.png_pic_center]

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

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /***
     * @Title FISRead02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 18:32
     * @Version 1.0.0
     */
    public class FISRead02 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");
            // 定义变量，保存数据
            int b;
            // 循环读取
            while ((b = fileInputStream.read()) != -1){
        
                System.out.println((char)b);
            }
            // 关闭资源
            fileInputStream.close();
        }
    }

![在这里插入图片描述][69e2afd778f4403486061ed6a7543ba4.png_pic_center]

> 小贴士：
> 
> 1.  虽然读取了一个字节，但是会自动提升为`int`类型。
> 2.  流操作完毕后，必须释放系统资源，调用`close`方法，千万记得。

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

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /***
     * @Title FISRead03
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 18:38
     * @Version 1.0.0
     */
    public class FISRead03 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");
            // 定义变量，作为有效个数
            int len;
            // 定义字节数组，作为装字节数据的容器
            byte[] b = new byte[2];
            // 循环读取
            while ((len = fileInputStream.read(b)) != -1){
        
                // 每次读取后,把数组变成字符串打印
                System.out.println(new String(b));
            }
            // 关闭资源
            fileInputStream.close();
        }
    }

![在这里插入图片描述][f26042ede3d045d183694dc90bc87709.png_pic_center]

错误数据`d`，是由于最后一次读取时，只读取一个字节`e`，数组中，上次读取的数据没有被完全替换，所以要通过`len`，获取有效的字节，代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /***
     * @Title FISRead04
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 18:42
     * @Version 1.0.0
     */
    public class FISRead04 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");
            // 定义变量，作为有效个数
            int len;
            // 定义字节数组，作为装字节数据的容器
            byte[] b = new byte[2];
            // 循环读取
            while ((len = fileInputStream.read(b)) != -1){
        
                // 每次读取后,把数组的有效字节部分，变成字符串打印
                System.out.println(new String(b,0,len));
            }
            // 关闭资源
            fileInputStream.close();
        }
    }

![在这里插入图片描述][4db2890686934bdcbe122e409091f17e.png_pic_center]

> 小贴士：
> 
> 使用数组读取，每次读取多个字节，减少了系统间的`IO`操作次数，从而提高了读写的效率，建议开发中使用。

### **2.6 字节流练习：图片复制** ###

#### **复制原理图解** ####

![在这里插入图片描述][84464f9c7406424d8dc59063de20196d.png_pic_center]

#### **案例实现** ####

复制图片文件，代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /***
     * @Title Copy
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 20:36
     * @Version 1.0.0
     */
    public class Copy {
        
        public static void main(String[] args) throws IOException {
        
            // 1.创建流对象
            // 1.1 指定数据源
            FileInputStream fis = new FileInputStream("D:\\java\\Java.jpeg");
            // 1.2 指定目的地
            FileOutputStream fos = new FileOutputStream("D:\\java\\javaCode\\Java.jpeg");
    
            // 2.读写数据
            // 2.1 定义数组
            byte[] b = new byte[1024];
            // 2.2 定义长度
            int len;
    
            // 2.3 循环读取
            while ((len = fis.read(b))!=-1) {
        
                // 2.4 写出数据
                fos.write(b, 0 , len);
            }
    
            // 3.关闭资源  流的关闭原则：先开后关，后开先关。
            fos.close();
            fis.close();
    
        }
    }

![在这里插入图片描述][8abf20425d3740769441886c41ebad4e.png_pic_center]

> 小贴士： 流的关闭原则：**先开后关，后开先关。**

## **第三章 字符流** ##

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以`Java`提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

### **3.1 字符输入流【`Reader`】** ###

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

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

### **3.2 `FileReader`类** ###

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

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

#### **构造方法** ####

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

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

构造举例，代码如下：

package com.dcxuexi.java23;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    
    /***
     * @Title FileReaderConstructor
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 20:46
     * @Version 1.0.0
     */
    public class FileReaderConstructor {
        
        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");
        }
    }

#### **读取字符数据** ####

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

package com.dcxuexi.java23;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /***
     * @Title FRRead
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 20:49
     * @Version 1.0.0
     */
    public class FRRead {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");
            // 定义变量，保存数据
            int b;
            // 循环读取
            while ((b=fileReader.read()) != -1){
        
                System.out.println("b : " + (char)b);
            }
            // 关闭资源
            fileReader.close();
        }
    }

![在这里插入图片描述][51ba3216493e47929d80079d3aeda5fe.png_pic_center]

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

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

package com.dcxuexi.java23;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /***
     * @Title FRRead02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 20:56
     * @Version 1.0.0
     */
    public class FRRead02 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");
            // 定义变量，保存有效字符个数
            int len;
            // 定义字符数组，作为装字符数据的容器
            char[] chub = new char[2];
            // 循环读取
            while ((len = fileReader.read(chub)) != -1){
        
                System.out.println(new String(chub));
            }
            // 关闭资源
            fileReader.close();
        }
    }

![在这里插入图片描述][1cebaada8ca647019b1c7a99937016cb.png_pic_center]

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

package com.dcxuexi.java23;
    
    import java.io.FileReader;
    import java.io.IOException;
    
    /***
     * @Title FRRead02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 20:56
     * @Version 1.0.0
     */
    public class FRRead02 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");
            // 定义变量，保存有效字符个数
            int len;
            // 定义字符数组，作为装字符数据的容器
            char[] chub = new char[2];
            // 循环读取
            while ((len = fileReader.read(chub)) != -1){
        
                System.out.println(new String(chub,0,len));
            }
            // 关闭资源
            fileReader.close();
        }
    }

![在这里插入图片描述][dcf7c64693f6472daef274a070d43e80.png_pic_center]

### **3.3 字符输出流【`Writer`】** ###

`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`类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

#### **构造方法** ####

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

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

构造举例，代码如下：

package com.dcxuexi.java23;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FileWriterConstructor
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:05
     * @Version 1.0.0
     */
    public class FileWriterConstructor {
        
        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");
        }
    }

#### **基本写出数据** ####

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

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FWWrite
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:07
     * @Version 1.0.0
     */
    public class FWWrite {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write.txt");
            // 写出数据
            fileWriter.write(97);// 写出第1个字符
            fileWriter.write('b');// 写出第2个字符
            fileWriter.write("国");// 写出第3个字符
            fileWriter.write(30000);// 写出第4个字符，中文编码表中30000对应一个汉字。
    
            //【注意】关闭资源时,与FileOutputStream不同。
            // 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
            fileWriter.close();
        }
    }

![在这里插入图片描述][46a050b1fc34479084893e74b72d10b5.png_pic_center]

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

#### **关闭和刷新** ####

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

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

代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FWWrite02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:17
     * @Version 1.0.0
     */
    public class FWWrite02 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write02.txt");
            // 写出数据，通过flush
            fileWriter.write('刷'); // 写出第1个字符
            fileWriter.flush();
            fileWriter.write('新'); // 继续写出第2个字符，写出成功
            fileWriter.flush();
    
            // 写出数据，通过close
            fileWriter.write('关'); // 写出第1个字符
            fileWriter.close();
            fileWriter.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
            fileWriter.close();
        }
    }

![在这里插入图片描述][bf2a378021704056a9b7a9a3f7ee74ab.png_pic_center]

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

#### **写出其他数据** ####

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

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FWWrite03
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:24
     * @Version 1.0.0
     */
    public class FWWrite03 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write03.txt");
            // 字符串转换为字节数组
            char[] chars = "我爱北京天安门".toCharArray();
            // 写出字符数组
            fileWriter.write(chars); // 我爱北京天安门
            // 写出从索引2开始，2个字节。索引2是'北'，两个字节，也就是'北京'。
            fileWriter.write(chars,2,2); // 北京
    
            // 关闭资源
            fileWriter.close();
        }
    }

![在这里插入图片描述][5f6b9c184c104b2d825c8853364d9c7b.png_pic_center]

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

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FWWrite04
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:29
     * @Version 1.0.0
     */
    public class FWWrite04 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write04.txt");
            // 字符串
            String str = "石家庄赵子龙VS包头吕布VS枣庄兰陵王";
            // 写出字符数组
            fileWriter.write(str);
            // 写出从索引6开始，6个字节。索引6是'V'，6个字节，也就是'VS包头吕布'。
            fileWriter.write(str,6,6);
            // 关闭资源
            fileWriter.close();
    
        }
    }

![在这里插入图片描述][8fe24f501587445db6573e26c4f0d47b.png_pic_center]

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

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title FWWrite05
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:44
     * @Version 1.0.0
     */
    public class FWWrite05 {
        
        public static void main(String[] args) throws IOException {
        
            // 使用文件名称创建流对象
            FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write04.txt",true);
            // 写出字符串
            String str ="VS合肥包拯";
            // 写出字符数组
            fileWriter.write(str);
            // 写出换行
            fileWriter.write("\r\n");
            // 写出字符串
            fileWriter.write("VS驻马店袁绍");
    
            // 关闭资源
            fileWriter.close();
        }
    }

![在这里插入图片描述][917dd7cb72bb4ae4a42024e36bf83a67.png_pic_center]

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

## **第四章 `IO`异常的处理** ##

### **`JDK7`前处理** ###

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

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title HandleException01
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 21:55
     * @Version 1.0.0
     */
    public class HandleException01 {
        
        public static void main(String[] args) {
        
            // 声明变量
            FileWriter fileWriter = null;
            try {
        
                //创建流对象
                fileWriter = new FileWriter("D:\\java\\javaCode\\File\\writeHandleException.txt");
                // 写出数据
                fileWriter.write("保定张翼德"); //保定张翼德
            } catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                // 释放资源
                try {
        
                    if (fileWriter != null){
        
                        fileWriter.close();
                    }
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][7712699aecf349d09332b1ebbf7a5843.png_pic_center]

### **`JDK7`的处理（扩展内容）** ###

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

格式：

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

代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title HandleException02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 22:05
     * @Version 1.0.0
     */
    public class HandleException02 {
        
        public static void main(String[] args) {
        
            // 创建流对象
            try (FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\writeHandleException2.txt") ) {
        
                // 写出数据
                fileWriter.write("石家庄赵子龙"); //石家庄赵子龙
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

![在这里插入图片描述][e9143ed6b8d94bae994933d13aa9c8e8.png_pic_center]

### **`JDK9`的改进（扩展内容）** ###

`JDK9`中`try-with-resource`的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动`close`，我们来了解一下格式。

改进前格式：

// 被final修饰的对象
    final Resource resource1 = new Resource("resource1");
    // 普通对象
    Resource resource2 = new Resource("resource2");
    // 引入方式：创建新的变量保存
    try (Resource r1 = resource1;
         Resource r2 = resource2) {
        
         // 使用对象
    }

改进后格式：

// 被final修饰的对象
    final Resource resource1 = new Resource("resource1");
    // 普通对象
    Resource resource2 = new Resource("resource2");
    
    // 引入方式：直接引入
    try (resource1; resource2) {
        
         // 使用对象
    }

改进后，代码使用演示：

package com.dcxuexi.java23;
    
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /***
     * @Title TryDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 22:13
     * @Version 1.0.0
     */
    public class TryDemo {
        
        public static void main(String[] args) throws IOException {
        
            // 创建流对象
            final  FileReader fr  = new FileReader("D:\\java\\javaCode\\File\\read.txt");
            FileWriter fw = new FileWriter("D:\\java\\javaCode\\File\\tryWrite.txt");
            // 引入到try中
            try (fr; fw) {
        
                // 定义变量
                int b;
                // 读取数据
                while ((b = fr.read())!=-1) {
        
                    // 写出数据
                    fw.write(b);
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

![在这里插入图片描述][517a8cb478594614983eaeea9f41a570.png_pic_center]

## **第五章 属性集** ##

### **5.1 概述** ###

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

### **5.2 `Properties`类** ###

#### **构造方法** ####

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

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

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

package com.dcxuexi.java23;
    
    import java.util.Properties;
    import java.util.Set;
    
    /***
     * @Title ProDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 22:23
     * @Version 1.0.0
     */
    public class ProDemo {
        
        public static void main(String[] args) {
        
            // 创建属性集对象
            Properties properties = new Properties();
            // 添加键值对元素
            properties.setProperty("filename", "java.txt");
            properties.setProperty("length", "20221212");
            properties.setProperty("location", "D:\\java\\javaCode\\File\\read.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));
            }
        }
    }

![在这里插入图片描述][3e8ee382c0b343a69c62969c6add08d4.png_pic_center]

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

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

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

filename=java.txt
    length=20221212
    location=D:\\java\\javaCode\\File\\read.txt

加载代码演示：

package com.dcxuexi.java23;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    
    /***
     * @Title ProDemo02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/12 22:33
     * @Version 1.0.0
     */
    public class ProDemo02 {
        
        public static void main(String[] args) throws IOException {
        
            // 创建属性集对象
            Properties pro = new Properties();
            // 加载文本中信息到属性集
            pro.load(new FileInputStream("D:\\java\\javaCode\\File\\properties.txt"));
            // 遍历集合并打印
            Set<String> strings = pro.stringPropertyNames();
            for (String key : strings ) {
        
                System.out.println(key + " -- " + pro.getProperty(key));
            }
        }
    }

![在这里插入图片描述][d6134cf6e8b24c87968dec1ce727a07d.png_pic_center]

注：文本数据中如果有`\`，需要使用`\\`替换。因为在`Java`中，反斜杠`\`是一个特殊的转义字符，所以需要前面再加一个反斜杠`\`，以表示转义。

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

[8f44361ef9fa454db5e34a03fef6e574.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e3d9339ddf924ee2b2afe3e569452895.png
[e1a08b489b3c466e830006c9fa2a43d5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/451e4546cf9c47039f7bdbc3cfa87818.png
[158494311c004588bf93cc98b83252b1.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f69ccf15b44a46fcbc0bf942c638160b.png
[6aca79b6ff06474382aeb24d4ee96af7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/dff10d6272734ec7aefa301fdff60ae4.png
[cb549b92135a441ab29c730acc609d67.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8eb2f55e2f9c4973a5b203d9de66bc7e.png
[adea72572f49410c85a17c6aab58beab.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/edd3d68c3ffc46178512055a235702ab.png
[dcaaee6a3d414afd8cba6ced11941525.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c0abea813311408f8776d1ab99484447.png
[69e2afd778f4403486061ed6a7543ba4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/20d3391e91e942aa81bed9b42ab02e31.png
[f26042ede3d045d183694dc90bc87709.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d47d87d9286d412b80286b498beae67c.png
[4db2890686934bdcbe122e409091f17e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/33012101ace74f60bb6cdf6f107a5ccc.png
[84464f9c7406424d8dc59063de20196d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c5ee33cced2942a491ce846a77d1cd56.png
[8abf20425d3740769441886c41ebad4e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2cd3e36cda684940977913ca66cc513d.png
[51ba3216493e47929d80079d3aeda5fe.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1e1590e789e948ea894969ef68539845.png
[1cebaada8ca647019b1c7a99937016cb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/80340cdaeeb24317bb362db2bed019fb.png
[dcf7c64693f6472daef274a070d43e80.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/76a020212c0a4bdbb491f2f3ba5779df.png
[46a050b1fc34479084893e74b72d10b5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/be355bd026ab4571a1d7329c5e46c8c0.png
[bf2a378021704056a9b7a9a3f7ee74ab.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7e9bd71190dc426a8bfde2ac1fdb9efc.png
[5f6b9c184c104b2d825c8853364d9c7b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fbf684bbe79f49b0920aa43a17e2bf20.png
[8fe24f501587445db6573e26c4f0d47b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b7f209ab7d1a46beaeab4b9c0fbb89bf.png
[917dd7cb72bb4ae4a42024e36bf83a67.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7d888c6527db43a392153bc1c2d6db02.png
[7712699aecf349d09332b1ebbf7a5843.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2330593913f24c0794643b4aaee51eb4.png
[e9143ed6b8d94bae994933d13aa9c8e8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2494905da3264ffd943af483a58f7488.png
[517a8cb478594614983eaeea9f41a570.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a39dd0b2ca094d39a807e18ce9b0ace5.png
[3e8ee382c0b343a69c62969c6add08d4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9661879e2e034d2792c67c7ef7893202.png
[d6134cf6e8b24c87968dec1ce727a07d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f39058d02f864522bf07f0ee931b6df1.png