全面简单总结JAVA中File类和IO的概念及用法【包含各种构造与通用方法、类之间的层次关系说明】（1万5千字）

字数很多，也较为全面。没有那么多专业术语，对重要的概念讲的很通俗。层次分得很详细，可以根据目录来了解对应模块，具体的实际用法请查看文献资料，本文仅做参考与了解。(1万5千字)

如果有什么错误的地方，还请不吝指出。

如果觉得不错，就收藏吧！

点赞！

一、File类

概述：java.io.File 类是文件和目录路径名的抽象表示，它是一个预定义的类（用来表示计算机上的文件或目录）。一个实例化的File对象，所表示的文件或目录可能是不存在的（在计算机上没有对应的文件或目录），但是这个对象是存在的）。

设计此类的作用：因此，在用此类去创建一个表示对应的文件\目录的File对象后（不管这个文件\目录是否存在），我们便可以使用此类所定义的方法去对这个File对象（文件\目录）进行创建、查找（所定义的属性值、存在与否）、删除等操作。

1、File类的初始属性值：

为了更为方便地对File对象（电脑上的文件或者目录）进行表示和操作，Java对其所有可能用到的属性值进行了预定义：

1. 路径名（path）：表示文件或目录的路径名。
2. 绝对路径名（absolutePath）：表示文件或目录的绝对路径名。
3. 父目录路径（parent）：表示文件或目录的父目录路径名。
4. 文件名（name）：表示文件或目录的名称。
5. 是否是绝对路径（isAbsolute）：表示文件或目录是否是绝对路径。
6. 最后修改时间（lastModified）：表示文件或目录的最后修改时间。
7. 文件大小（length）：表示文件的大小，以字节为单位。
8. 是否是目录（isDirectory）：表示文件或目录是否是目录。
9. 是否是文件（isFile）：表示文件或目录是否是文件。
10. 是否可读（canRead）：表示文件或目录是否可读。
11. 是否可写（canWrite）：表示文件或目录是否可写。
12. 是否隐藏（isHidden）：表示文件或目录是否隐藏。

2、File类的构造方法：

类的定义需要构造方法，以便在创建这个对象时对它的属性进行初始定义（定义它的在电脑上的路径）。构造方法的参数为一个重要的初始属性，及文件的路径（一个字符串）。因为我们创建File对象的时候，是需要在电脑上创建的，这就需要我们来指明在哪里创建这个对象（只是创建对象\或者说获取一个可能存在的文件或目录对象“根据文件路径名”，不是创建实例文件或目录“这需要调用File类定义的创建方法的“对File对象进行操作”）。

1、public File(String pathname) : 通过将给定的【路径名字符串转换为抽象路径名】来创建新的File实例对象。

//文件路径名
String pathname = "D:\\a.txt";
File file1 = new File(pathname);

File file2 = new File(D:\\a\\b.txt);
//如果没有指定具体路径名，只有文件名，则默认创建在本JAVA项目的目录下
File file3 = new File(c.txt);

2、public File(String parent,String child): 从父路径名字符串和子路径名字符串来创建新的File实例对象。

//通过父路径名和子路径名字符串
String parent = "D:\\a";
String child = "b.txt";
File file = new File(parent,child);

3、public File(File parent,String child): 从File实例对象（这里指它的路径，意会即可）的和子路径名字符串来创建新的File实例对象。

（注意：如果这里的File对象表示一个文件而不是文件夹”目录“，那么它的child参数会被忽略，直接再次创建该文件的File对象，所以我们应该用表示文件夹目录的File对象）

//通过父级File对象和子路径字符串
File parentDir = new File("D:\\a);
String child = "b.txt";
File file = new File(parentDir,child);

4、public File(URL uril):接受一个 URI 对象作为参数，该 URI 表示文件的统一资源标识符。使用 URI 对象可以更灵活地表示文件路径.

//使用URL
File file = new File(new URI("file:///path/to/file.txt"));

URL是一个类。在Java中，URL类用于表示统一资源定位符（Uniform Resource Locator），它提供了一种在网络上定位资源的方式。URL类包含了许多方法，可以用于解析URL、获取URL的各个部分（比如协议、主机、端口、路径等），以及打开连接到URL所表示的资源。

URL类通常用于在网络编程中，比如从Web服务器上获取数据或资源。它提供了一种方便的方式来处理URL，并且可以与其他网络相关的类（比如URLConnection）一起使用，以便进行网络操作。

总之，URL类是Java标准库中用于处理统一资源定位符的重要类之一。

3、File类的常用方法：

File类是Java标准库中用于表示文件和目录的类，它提供了许多方法用于对文件和目录进行操作。以下是File类的一些常用方法（都是public修饰的，因为是通用方法）：

1. String getName()：返回文件或目录的名称。
2. String getPath()：返回文件或目录的路径。
3. boolean isFile()：检查当前File对象是否表示一个文件。
4. boolean isDirectory()：检查当前File对象是否表示一个目录。
5. boolean exists()：检查文件或目录是否存在。
6. boolean canRead()：检查文件或目录是否可读。
7. boolean canWrite()：检查文件或目录是否可写。
8. boolean createNewFile()：创建一个新文件。
9. boolean mkdir()：创建一个单级目录。

10. public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。（创建多级，如a//b//）

11. String[] list()：返回目录中的文件和子目录的名称数组。
12. File[] listFiles()：返回目录中的文件和子目录的File对象数组。
13. boolean delete()：删除文件或目录。
14. long length()：返回文件的长度（以字节为单位）。
15. boolean renameTo(File dest)：重命名文件或目录。
16. long lastModified()：返回文件或目录最后修改的时间。
17. boolean isHidden()：检查文件或目录是否是隐藏的。
18. String[] list(FilenameFilter filter)：返回目录中满足指定过滤器条件的文件和子目录的名称数组。
19. File[] listFiles(FileFilter filter)：返回目录中满足指定过滤器条件的文件和子目录的File对象数组。
20. boolean setLastModified(long time)：设置文件或目录的最后修改时间。
21. boolean setReadOnly()：设置文件或目录为只读。
22. Path toPath()：将File对象转换为Path对象。

这些方法提供了对文件和目录进行基本操作的能力，可以用于检查文件或目录的属性、创建文件或目录、列出目录中的内容、删除文件或目录等。通过这些方法，可以方便地对文件系统进行操作。

一般所用到的方法（根据分类）：

1、获取功能：

-public String getAbsolutePath() :返回此File类的绝对路径名字符串。

-public String getPath(): 将此File转换为路径名字符串。就是构造路径，调用构造方法传入的路径。

-public String getName(): 返回由此File表示的文件或目录的名称。

-public long length(): 返回由此File表示的文件的长度。

2、判断功能：

-public boolean exists(): 返回由File对象表示的文件或目录是否实际存在。

-public boolean isDirectory(): 返回此File对象表示的是否为目录。

-public boolean isFile(): 返回此File对象表示的是否为文件。

3、创建删除功能：（返回是否成功 true / flase）

-public boolean creatNewFile(): 当且仅当此File对象表示的文件不存在时，创建一个这个File对象表示的新的空文件。【文件的创建】

-public boolean delete(): 删除此File对象表示的文件或目录。【文件与目录的删除】

-public boolean mkdir(): 创建此File对象表示的目录。【单级目录的创建】“需要其父目录存在：如：”D:a“--成功，因为D盘目录存在  ”D:a\\b--失败，因为a（父）目录不存在“  “。

-public boolean mkdirs(): 创建此File对象表示的目录。【多级目录的创建】“如果其父目录不存在会自动创建：如"D;\\a\\b ” b不存在，会创建b目录，再创建a目录 "。

4、目录的遍历：

-public String[] list(); 返回一个字符串数组数组，表示该File对象表示的目录中的所有子文件或目录的名称的字符串。

-public File[] listFile(): 返回一个File对象数组，表示该File对象表示的目录中的所有的子文件或目录的File对象

5、File类的总结

`File`类是Java标准库中用于表示文件和目录路径的类。它提供了一系列方法，可以用于创建、删除、重命名文件或目录，以及检查文件或目录的属性等操作。以下是`File`类的一些重要特点和功能总结：

1. 表示文件和目录：`File`类可以用来表示文件和目录的路径，可以通过构造方法传入文件或目录的路径字符串来创建`File`对象。

2. 文件和目录操作：`File`类提供了一系列方法，用于创建文件或目录、删除文件或目录、重命名文件或目录等操作。

3. 获取文件信息：`File`类提供了方法来获取文件的长度、最后修改时间等信息，以及检查文件是否存在、是否可读写等属性。

4. 目录内容操作：`File`类提供了方法来列出目录中的文件和子目录的名称，以及根据过滤器条件来获取目录中的文件和子目录。

5. 路径操作：`File`类提供了方法来获取文件或目录的路径、名称等信息，以及将`File`对象转换为`Path`对象。

总的来说，`File`类提供了对文件系统进行基本操作的能力，是Java中处理文件和目录的重要工具类之一。

二、IO

1、IO的概述：

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

注意：内存--->硬盘 ：输出数据。如将一个字节写入到D盘上的一个txt文档。

           硬盘--->内存 ：输入数据。如在D盘上的一个txt文档获取一个字节。

对于IO的理解，应该以内存为中心（电脑的运行内存，我们电脑的运行就是内存的数据流动，与其他的数据交换，而非硬盘”C盘或D盘等“），

在Java中，IO（输入/输出）是用于输入和输出操作的一组类和接口（注：不要以为它是一个类，它是一个概念）。在Java中，文件IO操作通常是在File对象的基础上进行的，但并不是所有的IO操作都需要File对象。File类主要用于表示文件和目录的路径，以及执行文件和目录的操作，比如创建、删除、重命名等。当需要对文件进行读取或写入操作时，通常会使用File对象来创建FileInputStream、FileOutputStream、FileReader、FileWriter等类的流对象，这些对象可以在文件上进行读写操作。（下文会对其分类说明）

此外：Java中也有许多其他类型的IO操作，比如网络IO、内存IO、标准输入输出等，这些操作并不一定需要File对象。例如，使用Socket类可以进行网络IO操作，使用System.in和System.out可以进行标准输入输出操作，而这些并不需要File对象。（了解）

2、IO的分类

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

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

• 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

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

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

3、Java的IO库

Java的IO库包含了许多类和接口，涵盖了各种输入输出操作。其中一些常用的类和接口包括：

1. InputStream和OutputStream：这两个抽象类是所有字节输入输出流的父类，提供了读取和写入字节的基本方法。

2. Reader和Writer：这两个抽象类是所有字符输入输出流的父类，提供了读取和写入字符的基本方法。

3. File和Path：这两个类用于表示文件和目录的路径，可以进行文件和目录的操作，比如创建、删除、重命名等。

4. FileInputStream和FileOutputStream：这两个类用于读取和写入文件的字节流。

5. FileReader和FileWriter：这两个类用于读取和写入文件的字符流。

6. BufferedReader和BufferedWriter：这两个类提供了缓冲功能，可以提高读取和写入的效率。

7. ByteArrayInputStream和ByteArrayOutputStream：这两个类用于在内存中进行字节输入输出操作。

8. CharArrayReader和CharArrayWriter：这两个类用于在内存中进行字符输入输出操作。

9. InputStreamReader和OutputStreamWriter：这两个类用于将字节流转换为字符流或将字符流转换为字节流。

10. Socket和ServerSocket：这两个类用于进行网络通信，包括TCP和UDP通信。

除了以上提到的类和接口，Java的IO库还包含了许多其他的类和接口，比如ObjectInputStream、ObjectOutputStream、DataInputStream、DataOutputStream等，用于处理对象输入输出、数据输入输出等。

4、IO库中顶级的父类

输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

InputStream和OutputStream是所有字节输入输出流的父类，提供了读取和写入字节的基本方法。Reader和Writer是所有字符输入输出流的父类，提供了读取和写入字符的基本方法。这些类都是抽象类，不能直接实例化，但是它们提供了很多基本的方法，可以被具体的子类所继承和实现。

除了最高层父类之外，Java中的IO类库还包含了许多其他的类和接口，比如FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter等，用于处理不同类型的输入输出操作。这些类和接口都是建立在最高层父类的基础之上的。

5、字节流类

（以文件为参数创建一个流对象，这个流对象便将文件与外界的通道打开了，借助这个流我们可以写入与读取数据）

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

一、字节输出流【OutputStream】抽象父类与它的一个简单子类【FileOutputStream】类

1、字节输出流【OutputStream】抽象父类

java.io.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、简单子类【FileOutputStream】字节输出流

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

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

构造方法：创建此类的对象，一个字节输入流对象。

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

• public FileOutputStream(File file)：创建文件输出流以写入由指定的 File 对象表示的文件。

• public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);

        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");

写出字节：write(int b) 方法，以流对象去调用这个方法每次可以写出一个字节数据，即将一个字节数据借助这个流对象进入到这个流对象所连接到的File对象所表示的文件。

 // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();

写出字节数组：write(byte[] b)，每次可以写出数组中的数据

  // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
      	// 字符串转换为字节数组
      	byte[] b = "黑马程序员".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从 off 索引开始，len 个字节。

 // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();

数据追加续写-构造不同：

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

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

• public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行：

Windows 系统里，换行符号是\r\n 。把

以指定是否追加续写了

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.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();
    }
}

输出结果：
a
b
c
d
e

扩展

• 回车符\r和换行符\n ：

  • 回车符：回到一行的开头（return）。

  • 换行符：下一行（newline）。

• 系统中的换行：

  • Windows 系统里，每行结尾是 回车+换行 ，即\r\n；

  • Unix 系统里，每行结尾只有 换行 ，即\n；

  • Mac 系统里，每行结尾是 回车 ，即\r。从 Mac OS X 开始与 Linux 统一。

二、字节输入流【InputStream]抽象父类与他的一个简单子类【FileInputStream】类：

1、字节输入流【InputStream]抽象类父类

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

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

• public abstract int read()： 从输入流读取数据的下一个字节。

• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b 中 。

小贴士：

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

2、简单子类【FileInputStream】类

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

构造方法

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

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

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

	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);

        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");

读取字节：read方法，每次可以读取一个字节的数据，提升为 int 类型，读取到文件末尾，返回-1。

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.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);
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

小贴士：

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

2. 流操作完毕后，必须释放系统资源，调用 close 方法，千万记得。

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

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

输出结果：
ab
cd
ed

6、字符流

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

一、字符输入流【Reader】抽象父类与它的一个简单子类【FileReader】类

1、字符输入流【Reader】抽象类父

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

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。

• public int read()： 从输入流读取一个字符。

• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf 中 。

2、一个简单子类【FileReader】类

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

小贴士：

1. 字符编码：字节与字符的对应规则。Windows 系统的中文编码默认是 GBK 编码表。

   idea 中 UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的 File 对象。

• FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

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

	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);

        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");

读取字符：read方法，每次可以读取一个字符的数据，提升为 int 类型，读取到文件末尾，返回-1。

public class FRRead {
    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();
    }
}
输出结果：
人
在
陕
北

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

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

public class FRRead {
    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();
    }
}
输出结果：
果子
饼干
白菜

二、字符输出流【Writer】抽象父类和他的一个简单子类【FileWriter】类

1、字符输出流【write】抽象父类

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() 关闭此流，但要先刷新它。

2、一个简单的子类【FileWriter】类

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

构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的 File 对象。

• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

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

// 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);

        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");

写出字符：write(int b) 方法，每次可以写出一个字符数据

public class FWWrite {
    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(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。

      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

关闭和刷新

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

• flush ：刷新缓冲区，流对象可以继续使用。

• close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

   // 使用文件名称创建流对象
        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();

写出其他数据

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

   public class FWWrite {
       public static void main(String[] args) throws IOException {
           // 使用文件名称创建流对象
           FileWriter fw = new FileWriter("fw.txt");
         	// 字符串
         	String msg = "我会弹钢琴";
   
         	// 写出字符数组
         	fw.write(msg); /我会弹钢琴
   
   		// 写出从索引2开始，2个字节。
           fw.write(msg,2,2);
   
           // 关闭资源
           fos.close();
       }
   }

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

   ​
   public class FWWrite {
       public static void main(String[] args) throws IOException {
           // 使用文件名称创建流对象
           FileWriter fw = new FileWriter("fw.txt");
         	// 字符串
         	String msg = "思考的角度";
   
         	// 写出字符数组
         	fw.write(msg); //思考的角度
   
   		// 写出从索引2开始，2个字节。
           fw.write(msg,2,2);	
   
           // 关闭资源
           fos.close();
       }
   }

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

   public class FWWrite {
       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();
       }
   }
   输出结果:
   我
   你

   小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

   当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

三、总结：本文对File类和IO的较为全面的总结到此结束，读者应应明白File类与流类之间的联系，以及File类所表示的意义，IO流对象的实际作用与它进行数据输入输出所借助的媒介。

如果觉得不错的话，收藏，点个赞。

如文章有错误的地方，还请不吝指出。

感谢收藏与点赞！