Java之File类（路径、静态变量、常用方法），IO（概述、分类），IO中的字节流，IO中的字符流

File类

1.概述：

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

java把电脑中的文件和文件夹（就是目录）封装为了一个File类，可以使用File类对文件和文件夹进行操作。

可以使用File类中的方法，一般会包括：

创建一个文件/文件夹

删除一个文件/文件夹

判断文件/文件夹是否存在

对文件夹进行遍历

获取文件的大小

 重点记住三个单词：file（文件）、directory（文件夹）、path（路径）。

2.绝对路径和相对路径的对比：

1. 绝对路径是一个完整的路径。以盘符（比如C:，D:）开始的路径，例如c:\\a.txt，C:\\Users\jupy\\Programs\\java\\code_0\\test.txt，D:\\demo\\b.txt
2. 相对路径是一个简化的路径，相对于当前项目的根目录。如果使用当前项目的根目录，路径可以简化书写，例如C:\\Users\jupy\\Programs\\java\\code_0\\test.txt可以简化为code_0\\test.txt。其中红色部分是当前项目的根目录。

注意：（1）路径是不区分大小写。（2）路径中的文件名称分隔符，在Windows中使用反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠；在linux种使用单个正斜杠，不需要转义。

3.File类的静态变量：

static String pathSeparator   与系统有关的路径分隔符，windows为分号，Linux为冒号。
static char pathSeparatorChar  与系统有关的路径分隔符。和上面是一样的
static String separator   与系统有关的默认名称分隔符（文件名称分隔符），Windows为反斜杠。linux为正斜杠。
static char separatorChar  与系统有关的默认名称分隔符。和上面是一样的。

注意：路径不能写死了，不能写死用windows格式或者linux格式，当代码放在不同系统下的时候时会报错的。
C:\develop\a\a.txt  Windows系统
C:/develop/a/a.txt  Linux系统
“C:”+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"  自动选择路径格式

import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator; // 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
        char pathSeparatorChar = File.pathSeparatorChar; // 与系统有关的路径分隔符，被表示为一个字符。
        String separator = File.separator; // 与系统有关的默认名称分隔符（windows是反斜杠\），为了方便，它被表示为一个字符串。
        char separatorChar = File.separatorChar; // 和上面一样，但是是字符。
        System.out.println("本系统的路径分隔符String："+pathSeparator+
                "   本系统的路径分隔符char："+pathSeparatorChar+
                " 本系统的默认名称分隔符String："+separator+
                " 本系统的默认名称分隔符char："+separatorChar);
        // 本系统的路径分隔符String：;   本系统的路径分隔符char：; 本系统的默认名称分隔符String：\ 本系统的默认名称分隔符char：\
    }
}

 4.构造方法（3种）创建新的File实例，该实例要么是文件，要么是文件夹。

• public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
  注意：（1）路径（pathname）可以是以文件结尾，也可是文件夹结尾。
             （2）路径可以是相对路径，也可以是绝对路径。
             （3）路径可以是存在，也可以是不存在。因为创建File对象只是把字符串路径封装为File对象，不考虑路径的真假情况。
• public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
  好处：父路径和子路径可以单独写，使用起来非常灵活，父路径和子路径都可以变化。
• public File(File parent, String child) ：从父抽象路径名和子路径名字符串组合创建新的 File实例。
  好处：（1）父路径和子路径可以单独写，使用起来非常灵活，父路径和子路径都可以变化。
             （2）父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象。

 5.常用方法（大致分为4类）

1. 获取功能的方法
2. 判断功能的方法
3. 创建删除功能的方法
4. 目录遍历功能的方法

5.1.获取功能的方法

• public String getAbsolutePath() ：返回文件/文件夹的绝对路径。
• public String getPath() ：返回文件/文件夹的构造路径。
• public String getName() ：返回由此File表示的文件/文件夹的名称。
• public long length() ：返回由此File表示的文件的长度（仅指文件的大小）。
  注意：文件夹是没有大小的概念，不管里面是否存在文件，都是返回0. 

import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        File f = new File("C:\\Users\\jupy\\Documents\\Scripts\\bbb.java");
        System.out.println("文件绝对路径:"+f.getAbsolutePath()); // 文件绝对路径:C:\Users\jupy\Documents\Scripts\bbb.java
        System.out.println("文件构造路径:"+f.getPath()); // 文件构造路径:C:\Users\jupy\Documents\Scripts\bbb.java
        System.out.println("文件名称:"+f.getName()); // 文件名称:bbb.java
        System.out.println("文件长度:"+f.length()+"字节"); // 文件长度:0字节
        File f2 = new File("Scripts\\bbb");
        System.out.println("目录绝对路径:"+f2.getAbsolutePath()); // 目录绝对路径:C:\Users\jupy\IdeaProjects\basic_code\Scripts\bbb
        System.out.println("目录构造路径:"+f2.getPath()); // 目录构造路径:Scripts\bbb
        System.out.println("目录名称:"+f2.getName()); // 目录名称:bbb
        System.out.println("目录长度:"+f2.length()); // 目录长度:0
    }
}

5.2.判断功能的方法

• public boolean exists() ：此File表示的文件/文件夹是否实际存在。用于判断构造方法中的路径是否存在，存在：true；不存在：false。
• public boolean isDirectory() ：此File表示的是否为文件夹。用于判断构造方法中给定的路径是否以文件夹结尾
• public boolean isFile() ：此File表示的是否为文件。 用于判断构造方法中的路径是否以文件结尾。

注意：

（1）电脑的硬盘中只有文件/文件夹，两个方法（isFile和isDirectory）是互斥的。

（2）这两个方法（isFile和isDirectory）使用前提，路径必须是存在的，否则都返回false。

import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\jupy\\Documents\\Scripts\\test.txt"); // 文件
        File f2 = new File("C:\\Users\\jupy\\Documents\\Scripts"); // 文件夹
        File f3 = new File("D:\\Users\\jupy\\Documents\\Scripts"); // 不存在的文件夹
        // 判断是否存在
        System.out.println("C:\\Users\\jupy\\Documents\\Scripts\\test.txt 是否存在:"+f1.exists()); // C:\Users\jupy\Documents\Scripts\test.txt 是否存在:true
        System.out.println("C:\\Users\\jupy\\Documents\\Scripts 是否存在:"+f2.exists()); // C:\Users\jupy\Documents\Scripts 是否存在:true
        // 判断是文件还是目录
        System.out.println("C:\\Users\\jupy\\Documents\\Scripts 文件?:"+f2.isFile()); // C:\Users\jupy\Documents\Scripts 文件?:false
        System.out.println("C:\\Users\\jupy\\Documents\\Scripts 目录?:"+f2.isDirectory()); // C:\Users\jupy\Documents\Scripts 目录?:true
        System.out.println("D:\\Users\\jupy\\Documents\\Scripts 目录?:"+f3.isDirectory()); // D:\Users\jupy\Documents\Scripts 目录?:false
    }
}

5.3. 创建删除功能的方法

• public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。创建的是文件！
  创建文件的路径和文件名称在构造方法中给出（构造方法的参数）。如果文件不存在，就创建文件返回true；如果文件存在，则不会创建，返回false。
  注意：（1）此方法只能创建文件，不能创建文件夹。（2）创建文件的路径必须存在，否则会抛出IOException异常，我们调用这个方法，就必须处理这个异常，要么throw，要么try-catch。
• public boolean delete() ：删除由此File表示的文件/目录。
  注意：delete方法直接在硬盘删除文件/文件夹，不走回收站，删除要谨慎！
• public boolean mkdir() ：创建由此File表示的目录。创建的是文件夹！只能创建单级空文件夹。
  创建文件夹的路径和文件夹名称在构造方法中给出（构造方法的参数）。如果文件夹不存在，就创建文件返回true；如果文件夹存在，则不会创建，返回false。
  注意：（1）此方法只能创建文件夹，不能创建文件。（2）如果要创建多级文件夹，不会发生任何异常，一律返回false。
• public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。创建多层文件夹，也可以创建单级空文件夹，即使父类文件夹不存在，也会一并创建。

import java.io.File;
import java.io.IOException;
public class FileTest {
    public static void main(String[] args) throws IOException {
        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println(f.getAbsoluteFile());
        System.out.println("文件aaa.txt是否存在:"+f.exists()); // 文件aaa.txt是否存在:false
        // 注意一定要处理异常，要么throw，要么try-catch。这里选择前者。
        System.out.println("文件aaa.txt是否创建:"+f.createNewFile()); // 文件aaa.txt是否创建:true
        System.out.println("文件aaa.txt是否存在:"+f.exists()); // 文件aaa.txt是否存在:true
        // 目录的创建
        File f2= new File("newDir");  // 单级空目录
        System.out.println("文件夹newDir是否存在:"+f2.exists());// 文件夹newDir是否存在:false
        System.out.println("文件夹newDir是否创建:"+f2.mkdir()); // 文件夹newDir是否创建:true
        System.out.println("文件夹newDir是否存在:"+f2.exists());// 文件夹newDir是否存在:true
        // 创建多级目录
        File f3= new File("newDira\\newDirb");  // 多级目录，其中父目录不存在
        System.out.println("使用mkdir，创建多级文件夹是否创建："+f3.mkdir());// 使用mkdir，创建多级文件夹是否创建：false
        System.out.println("使用mkdirs，创建多级文件夹是否创建："+f3.mkdirs());// 使用mkdirs，创建多级文件夹是否创建：true
        // 文件的删除
        System.out.println("单级文件aaa.txt是否删除："+f.delete());// 单级文件aaa.txt是否删除：true
        // 目录的删除
        System.out.println("单级文件夹newDir是否删除："+f2.delete());// 单级文件夹newDir是否删除：true
        System.out.println("多级文件夹newDira\\newDirb是否删除："+f3.delete());// 多级文件夹newDira\newDirb是否删除：true
    }
}

5.4.目录（文件夹）遍历的方法

• public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
  遍历构造方法中给出的目录，会获取目录中所文件/文件夹的名称，把获取到的多个名称存储到一个String类型数组中。
• public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
  遍历构造方法中给出的目录，会获取目录中所有的文件/文件夹，把文件/文件夹封装为File对象存储到File数组中

注意：

（1）list方法和listFiles方法遍历的是构造方法中给出的目录。

（2）如果构造方法中给出的目录路径不存在，会抛出NullPointerException空指针异常；如果构造方法中给出的路径不是一个目录，也会抛出空指针异常。

import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        File dir = new File("C:\\Users\\jupy\\Documents\\电子版书籍");
        //获取当前目录下的文件以及文件夹的名称。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //获取dir目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

6.案例：

1.文件搜索。

题目要求：搜索D:aaa目录中的.java文件。

分析：（1）目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。（2） 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        File dir = new File("C:\\Users\\jupy\\Documents\\电子版书籍");
        //获取当前目录下的文件以及文件夹的名称。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //获取dir目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

2.文件过滤器优化。

题目要求：java.io.FileFilter是一个接口，是File的过滤器。该接口的对象可以传递给 File类的listFiles(FileFilter）作为参数，接口中只有一个方法。boolean accept(File pathname)：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：（1）接口作为参数，需要传递子类对象，重写其中的方法。可以选择匿名内部类方式。（2）accept方法，参数为File，表示当前File夏所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留的规则：要么是.java文件，要么是目录用于继续遍历。（3）通过过滤的作用，listFiles(FileFilter)返回的数组元素中，子对象都是符合条件的，可以直接打印。

import java.io.File;
import java.io.FileFilter;
public class FileTest {
    public static void main(String[] args) {
        File dir = new File("D:\\aaa");
        printDir2(dir);
    }
    public static void printDir2(File dir) {
        // 匿名内部类方式,创建过滤器子类对象
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".java")||pathname.isDirectory();
            }
        });
        // 循环打印
        for (File file : files) {
            if (file.isFile()) {
                System.out.println("文件名:" + file.getAbsolutePath());
            } else {
                printDir2(file);
            }
        }
    }
}

优化：FileFilter 是只有一个方法的接口，因此可以用lambda表达式简写。

public static void printDir3(File dir) {
    // lambda的改写
    File[] files = dir.listFiles(f ->{return f.getName().endsWith(".java") || f.isDirectory();});
    // 循环打印
    for (File file : files) {
        if (file.isFile()) {
            System.out.println("文件名:" + file.getAbsolutePath());
        } else {
            printDir3(file);
        }
    }
}

IO

概述

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

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

IO的分类

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

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

流的数据的类型分为：字节流和字符流。1个字符=2个字节，1个字节=8个二进制。

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

IO的流向说明图解

顶级父类们

字节流（OutputStream和InputStream）

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

1.字节输出流（OutputStream）

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。以下是一些字节输出流的基本共性功能方法。

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。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) ：将指定的字节输出流。

字节输出流的子类FileOutputStream类

FileOutputStream是OutputStream抽象类的子类。java.io.FileOutputStream extends OutputStream 类是文件字节输出流，用于将内存中的数据写入到硬盘的文件中。

1.1.构造方法

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

构造方法的参数：表示写入数据的目的地。String name：目的地的一个文件路径。File file：目的地是一个文件。

构造方法的作用：

（1）创建一个FileOutputStream对象。
（2）会根据构造方法中传递的文件/文件路径，创建一个空的文件。
（3）会把FileOutputStream对象指向创建好的文件

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

1.2.从内存写入硬盘，写出字节数据

写入数据的原理（内存-->硬盘）：java程序  ---> JVM（虚拟机）----> OS（操作系统）-----> OS调用写数据的方法----> 把数据写入文件中。

字节输出流的使用步骤（重点）：
      （1）创建一个FileOutputStream对象，构造方法中传递写入数据的目的地。
      （2）调用FileOutputStream对象中的write方法，将数据写入到文件中。
      （3）调用OutputStream对象中的close方法释放资源（流的使用会占用一定的内存，使用完毕要把内存释放，提高程序的效率）

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个FileOutputStream对象，构造方法中传递写入数据的目的地。相对路径，项目根目录下.
        FileOutputStream fos1 = new FileOutputStream("a.txt");
        FileOutputStream fos2 = new FileOutputStream("b.txt");  //  创建一个空文件
        // 2.调用FileOutputStream对象中的write方法，将数据写入到文件中。
        fos1.write(97);
        // 3.释放资源
        fos1.close();

        File file1 = new File("a.txt");
        File file2 = new File("b.txt");
        File file3 = new File("c.txt");
        file3.createNewFile(); // 使用File中的方法创建一个空文件
        System.out.println(file1.length());  // 1 表示文件的大小现在是1字节。
        System.out.println(file2.length());  // 0 表示文件的大小现在是0字节,是空文件，什么东西都没有。
        System.out.println(file3.length());  // 0 表示文件的大小现在是0字节,什么东西都没有。
    }
}

当打开a.txt，里面并不是数字97而是字母a，文件存储原理如下：

上面已经可以直接使用write方法写入一个字节，但是需要一次性写入多个字节，方法如下：
         （1）public void write(byte[]  b)：将b.length个字节写入此输出流。
         （2）public void write(byte[]  b，int off ，int len)：从指定的字节数组，从偏移量off开始的len个字节写入此输出流。

字符数组可以通过String类中的方法，把字符串转换为字节数组。String类中有一个getBytes方法：byte[] getBytes()

写入多字节（字节数组）注意：

如果碰到的字节是正数（0-127），那么显示的时候会查询ASIIC表。如果碰到的字节是负数，那该字节会和下一个字节组合成一个中文显示，查询系统默认码表（中文系统GBK）。

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个FileOutputStream对象，构造方法中传递写入数据的目的地。相对路径，项目根目录下.
        FileOutputStream fos = new FileOutputStream("a.txt");
        // 向文件中写入100
        fos.write(49); // 对应的ASIIC码是1
        fos.write(48); // 对应的ASIIC码是0
        fos.write(48); // 对应的ASIIC码是0
        // 等效于下面的一次性写入,继续在后面写入100
        byte[] bytes = {49,48,48};
        fos.write(bytes);
        byte[] bytes1 = {65,66,67,68,69};  // ABCD
        fos.write(bytes1);
        // 因为第一个是负数，所以第一个和第二个会组合在一起然后在GBK表中查找对应的中文
        fos.write(50); // 2
        byte[] bytes2 = {-65,66,67,68,69};  // GBk格式: 緽CDE。 UTF-8格式:�BCDE ISO-8859-1格式：¿BCDE
        fos.write(bytes2);
        fos.write(51); //3
        byte[] bytes3 = {-65,66,-67,68,69}; // GBk格式: 緽紻E。  UTF-8格式:�B�DE ISO-8859-1格式：¿B½DE
        fos.write(bytes3);
        fos.write(54); // 6
        byte[] bytes6 = {65,66,-67,68,-69}; // GBk格式: AB紻�。 UTF-8格式:AB�D� ISO-8859-1格式：AB½D»
        fos.write(bytes6);
        fos.write(56); // 8
        byte[] bytes8 = {-65,-66,-67,68,69}; //GBk格式: 烤紻E。 UTF-8格式:���DE ISO-8859-1格式：¿¾½DE
        fos.write(bytes8);
        fos.write(52); // 4
        byte[] bytes4 = {-65,66,-67,68,-69}; //GBk格式: 緽紻�。  UTF-8格式:�B�D� ISO-8859-1格式：¿B½D»
        fos.write(bytes4);
        fos.write(55); // 7
        byte[] bytes7 = "你好".getBytes();  //GBk格式: 浣犲ソ。  UTF-8格式:你好 ISO-8859-1格式：你好
        System.out.println(Arrays.toString(bytes7)); // [-28, -67, -96, -27, -91, -67] 因为java是utf-8编码的，3个字节为一个中文
        fos.write(bytes7);
        fos.write(57); // 9
        byte[] bytes9 = {-28, -67, -96, -27, -91, -67}; //GBk格式: 緽紻�。  UTF-8格式:�B�D� ISO-8859-1格式：¿B½D»
        fos.write(bytes9);
        fos.close();  // 写入的内容为：100100ABCDE2緽CDE3緽紻E6AB紻�8烤紻E4緽紻�
    }
}

 

（2）写出字节数组

（3）写出指定长度字节数组

1.3.数据追加续写

每次程序运行，创建输出流对象，都会清空目标文件中的数据。想要保留目标文件中数据，还能继续添加新数据则需要在构造方法的参数中再传入一个Boolean类型的值。

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

这两个构造方法，参数中都需要传入一个boolean类型的值， true 表示追加数据， false 表示清空原有数据。

1.4写出换行

2.字节输入流（InputStream）

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

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。close方法，当完成流的操作时，必须调用此方法，释放系统资源。
• public abstract int read() ： 从输入流读取数据的下一个字节。
• public int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

字节输入流的子类FileInputStream类

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

2.1构造方法

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

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

2.2读取字节数据

（1）读取字节

（2）读取字节数组

3.字节流案例

字符流

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

1.字符输入流（Reader）

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

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

字符输入流的子类FileReader类

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
备注：（1）字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。idea中UTF-8。
           （2）字节缓冲区：一个字节数组，用来临时存储字节数据。

1.1.构造方法

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

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

1.2.读取字符数据

（1）读取字符

（2）读取字符数组

2.字符输出流（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() ：关闭此流，但要先刷新它。

字符输出流的子类FileWriter类

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

2.1.构造方法

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

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

2.2.基本写出数据

（1）写出字符

（2）写出字符数组

（3）写出字符串

（4）续写和换行

2.3.关闭和刷新

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

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