【小白看的Java教程】第三十七章，Mr.R和Mr.W：Java中的IO【荐】

File类（掌握）

File课理解为文件和文件夹（目录），用于表示磁盘中某个文件或文件夹的路径。该类包含了文件的创建、删除、重命名、判断是否存在等方法。

只能设置和获取文件本身的信息（文件大小，是否可读），不能设置和获取文件里面的内容。

• Unix: 严格区分大小写，使用”/”来表示路径分隔符。

• Windows: 默认情况下是不区分大小写的，使用”\”来分割目录路径。但是在Java中一个”\”表示转义，所以在Windows系统中就得使用两个”\”。

操作File常见方法：

• String getName()：获取文件名称

• String getPath()：获取文件路径

• String getAbsolutePath()：获取绝对路径

• File getParentFile()：获取上级目录文件

• boolean exists()：判断文件是否存在

• boolean isFile() ：是否是文件

• boolean isDirectory()：判断是否是目录

• boolean delete() ：删除文件

• boolean mkdirs()：创建当前目录和上级目录

• File[] listFiles() ：列出所有文件对象

public class FileDemo {

    public static void main(String[] args) throws Exception {

        File f = new File("C:/test/123.txt");

        System.out.println(f.getName());//123.txt

        System.out.println(f.getPath());//C:/test/123.txt

        System.out.println(f.getAbsolutePath());//C:/test/123.txt

        System.out.println(f.getParentFile().getName());//test

        System.out.println(f.exists());//true

        System.out.println(f.isFile());//true

        System.out.println(f.isDirectory());//false

        //如果当前文件的父文件夹不存在,则创建

        if(!f.getParentFile().exists()) {

            f.getParentFile().mkdirs();

        }

        //列出当前文件夹中所有文件

        File[] fs = f.getParentFile().listFiles();

        for (File file : fs) {

            System.out.println(file);

        }

    }

}

列出给定目录中的全部文件的路径，包括给定目录下面的所有子目录。

public static void list(File file) {

    if (file.isDirectory()) {

        // 如果是文件夹，则继续列出

        File[] fs = file.listFiles();

        if (fs != null) {

            for (File f : fs) {

                list(f);

            }

        }

    }

    System.out.println(file);

}

字符编码

字符编码的发展历程（了解）

阶段一：

计算机只认识数字，在计算机里一切数据都是以数字来表示，因为英文符号有限，所以规定使用的字节的最高位是0。每一个字节都是以0~127之间的数字来表示，比如A对应65，a对应97。此时把每一个字节按照顺序存放在一张表格中，这就是美国标准信息交换码——ASCII编码表。

阶段二：

随着计算机在全球的普及，很多国家和地区都把自己的字符引入了计算机，比如汉字。此时发现一个字节（128个）能表示数字范围太小，而汉字太多，128个数字不能包含所有的中文汉字，那么此时就规定使用两个字节一起来表示一个汉字。

规定：原有的ASCII字符的编码保持不变，仍然使用一个字节表示，为了区别一个中文字符与两个ASCII码字符，中文字符的每个字节最高位（符号位）规定为1（中文的二进制是负数），该规范就是GB2312编码表。后来在GB2312码表的基础上增加了更多的中文汉字，也就出现了更强大的GBK码表。

阶段三：

中国人是认识汉字的，现在需要和外国人通过网络交流，此时需要把把汉字信息传递给外国人，但外国的码表中没有收录汉字，此时就会把汉字显示为另一个符号甚至不能识别的乱码。为了解决各个国家因为本地化字符编码带来的影响，就干脆把全世界所有的符号统一收录进Unicode编码表。

如果使用Unicode码表，那么某一个字符在全世界任何地方都是固定的。比如’哥’这个字，在任何地方都是以十六进制的54E5来表示，因此说Unicode是国际统一编码。

常见的字符编码和操作（了解）

常见的字符集

• ASCII：占一个字节，只能包含128个符号。不能表示汉字。

• ISO-8859-1：也称之为latin-1，占一个字节，收录西欧语言，不能表示汉字。

• GB2312/GBK/GB18030：占两个字节，支持中文。

• ANSI：占两个字节，在简体中文的操作系统中ANSI 就指的是 GBK。

• UTF-8：是一种针对Unicode的可变长度字符编码，是Unicode的实现方式之一，支持中文。在开发中建议使用。

• UTF-8 BOM：是微软搞出来的一种编码，不要使用。

存储字母、数字、汉字：

存储字母和数字无论是什么字符集都占1个字节.

存储汉字，GBK家族占两个字节，UTF-8家族占3个字节。

不能使用单字节的字符集（ASCII、ISO-8859-1）来存储中文，否则会乱码。

字符的编码和解码操作（掌握）

数据在网络上传输是以二进制的格式，二进制格式就是byte数组，此时需要把信息做编码和解码处理。

• 编码：把字符串转换为byte数组 String—>byte[]

• 解码：把byte数组转换为字符串 byte[]—>String

注意：一定要保证编码和解码的字符相同，才能正确解码出信息。

经典案例：在表单中填写中文，为什么在服务端看到的是乱码问题。

情景分析，比如浏览器使用UTF-8编码，服务器使用ISO-8859-1编码。

此时编码和解码的字符类型不同，那么乱码就出现了。

先来分析乱码产生的原因：

乱码的解决方案：

public class CodeDemo {

    public static void main(String[] args) throws Exception {

        String input = "龙哥";//模拟用户输入的中文数据

        //编码操作：String -> byte[]

        byte[] data = input.getBytes("UTF-8");

        System.out.println(Arrays.toString(data));//[-23, -66, -103, -27, -109, -91]

        //解码操作：byte[] -> String

        //因为服务器时老外写的,老外在解码的时候使用ISO-8859-1,此时就乱码了

        String ret = new String(data, "ISO-8859-1");

        System.out.println(ret);//输出：龙哥

        //---------------------------------------------

        //解决方案：重新对乱码编码回到byte[],重新按照UTF-8解码

        data = ret.getBytes("ISO-8859-1");

        System.out.println(Arrays.toString(data));//[-23, -66, -103, -27, -109, -91]

        ret = new String(data,"UTF-8");

        //---------------------------------------------

        System.out.println(ret);//输出：龙哥

    }

}

IO流操作

IO概述（了解）

什么是IO，Input和Output，即输入和输出。

电脑相关的IO设备：和电脑通信的设备，此时要站在电脑的角度，把信息传递给电脑叫输入设备，把电脑信息传递出来的叫输出设备。

• 输入设备：麦克风、扫描器、键盘、鼠标等

• 输出设备：显示器、打印机、投影仪、耳机、音响等

为什么程序需要IO呢？

案例1：打游戏操作，需要存储游戏的信息。

• 此时需要把游戏中的数据存储起来，数据只能存储在文件中。

案例2：打游戏操作，需求读取之前游戏的记录信息，数据存储在一个文件中的。

• 此时游戏程序需要去读取文件中的数据，并显示在游戏中。

IO操作是一个相对的过程，一般的，我们在程序角度来思考（程序的内存）。

• 程序需要读取数据：文件——>程序，输入操作

• 程序需要保存数据：程序——>文件，输出操作

IO操作示意图（了解）

讲解IO知识点的时候，习惯和生活中的水流联系起来，一起来看看复古的水井和水缸。

此时站在水缸的角度，分析IO的操作方向：

输入操作：水井——>水缸

输出操作：水缸——>饭锅

注意：谁拥有数据，谁就是源，把数据流到哪里，哪里就是目标。那么，请问水缸是源还是目标。

流的分类（掌握）

根据流的不同特性，流的划分是不一样的，一般按照如下情况来考虑：

• 按流动方向：分为输入流和输出流

• 按数据传输单位：分为字节流和字符流，即每次传递一个字节（byte）或一个字符（char）

• 按功能上划分：分为节点流和处理流，节点流功能单一，处理流功能更强

流的流向是相对的，我们一般站在程序的角度：

• 程序需要数据 → 把数据读进来 → 输入操作（read）：读进来

• 程序保存数据 → 把数据写出去 → 输出操作（write）：写出去

六字箴言：读进来，写出去（仔细揣摩这六个字有什么高深的含义）

四大基流

操作IO流的模板：

1):创建源或者目标对象(挖井).

 输入操作:    把文件中的数据流向到程序中,此时文件是源,程序是目标.

 输出操作:    把程序中的数据流向到文件中,此时文件是目标,程序是源.

2):创建IO流对象(水管).

 输入操作:     创建输入流对象.

 输出操作:     创建输出流对象.

3):具体的IO操作.

 输入操作:    输入流对象的read方法.

 输出操作:    输出流对象的write方法.

4):关闭资源(勿忘). 一旦资源关闭之后,就不能使用流对象了,否则报错.

 输入操作:    输入流对象.close();

 输出操作:    输出流对象.close();

注意：

• 四大抽象流是不能创建对象的，一般的我们根据不同的需求创建他们不同的子类对象，比如操作文件时就使用文件流。
• 不管是什么流，操作完毕都必须调用close方法，释放资源。

常见输入输出流

##InputStream（字节输入流）
类的声明为：

public abstract class InputStream extends Object implements Closeable

表示字节输入流的所有类的超类。

常用方法：

• public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。 InputStream 的 close 方法不执行任何操作。

• public abstract int read() throws IOException：从输入流中读取一个字节数据并返回该字节数据，如果到达流的末尾，则返回 -1。

• public int read(byte[] buff) throws IOException：从输入流中读取多个字节数据，并存储在缓冲区数组 buff 中。返回已读取的字节数量，如果已到达流的末尾，则返回 -1。

##OutputStream（字节输出流）
类的声明为：public abstract class OutputStream extends Object implements Closeable, Flushable，表示字节输出流的所有类的超类。
常用方法：

• public void close() throws IOException：关闭此输出流并释放与此流有关的所有系统资源。

• public abstract void write(int b) throws IOException：将指定的一个字节数据b写入到输出流中。

• public void write(byte[] buff) throws IOException：把数组buff中所有字节数据写入到输出流中。

• public void write(byte[] b, int off,int len) throws IOException：把数组buff中从索引off 开始的len 个字节写入此输出流中。

##Reader（字符输入流）
类的声明为：

public abstract class Reader extends Object implements Readable, Closeable

表示字符输入流的所有类的超类。

常用方法：

• public abstract void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
• public int read() throws IOException：从输入流中读取一个字符数据并返回该字符数据，如果到达流的末尾，则返回 -1。
• public int read(char[] cbuf) throws IOException：从输入流中读取多个字符，并存储在缓冲区数组 cbuf 中。返回已读取的字符数，如果已到达流的末尾，则返回 -1。

##Writer（字符输出流）

类的声明为：

public abstract class Writer extends Object implements Appendable, Closeable, Flushable

表示字符输出流的所有类的超类。

常用方法：

• public abstract void flush() throws IOException：刷新此输出流并强制写出所有缓冲的输出字符。

• public abstract void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。

• public void write(int c) throws IOException：将指定的一个字符数据c写入到输出流中。

• public void write(char[] cbuf) throws IOException：把数组cbuf中cbuf.length 个字符数据写入到输出流中。

• public abstract void write(char[] cbuf, int off,int len) throws IOException：把数组cbuf中从索引off 开始的len 个字符写入此输出流中。

• public void write(String str) throws IOException：将str字符串数据写入到输出流中。

##文件流（重点）
当程序需要读取文件中的数据或者把数据保存到文件中去，此时就得使用文件流，但是注意只能操作纯文本文件（txt格式），不要使用Word、Excel。文件流比较常用。
需求1：使用文件字节输出流，把程序中数据保存到result1.txt文件，操作英文

private static void test1() throws Exception {
	//1):创建源或者目标对象
	File dest = new File("file/result1.txt");
	//2):创建IO流对象
	FileOutputStream out = new FileOutputStream(dest);
	//3):具体的IO操作
	out.write(65);//输出A
	out.write(66);//输出B
	out.write(67);//输出C
	String str = "to be or not to be";
	out.write(str.getBytes());//输出str字符串中所有内容
	//4):关闭资源(勿忘)
	out.close();
}

需求2：使用文件字节输入流，读取result1.txt文件中的数据

private static void test2() throws Exception {
	//1):创建源或者目标对象
	File src = new File("file/result1.txt");
	//2):创建IO流对象
	FileInputStream in = new FileInputStream(src);
	//3):具体的IO操作
	System.out.println((char)in.read());//读取A字节
	System.out.println((char)in.read());//读取B字节
	System.out.println((char)in.read());//读取C字节
	byte[] buff = new byte[5];//准备容量为5的缓冲区
	int len = in.read(buff);//读取5个字节数据,并存储到buff数组中
	System.out.println(Arrays.toString(buff));//[116, 111, 32, 98, 101]
	System.out.println(len);//返回读取了几个字节
	//4):关闭资源(勿忘)
	in.close();
}

需求3：使用文件字符输出流，把程序中数据保存到result2.txt文件，操作中文

private static void test3() throws Exception {
	//1):创建源或者目标对象
	File dest = new File("file/result2.txt");
	//2):创建IO流对象
	FileWriter out = new FileWriter(dest);
	//3):具体的IO操作
	out.write('辛');//输出A
	out.write('弃');//输出B
	out.write('疾');//输出C
	String str = "众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。";
	out.write(str.toCharArray());
	out.write(str);//String的本质就是char[]
	//4):关闭资源(勿忘)
	out.close();
}

需求4：使用文件字符输入流，读取result2.txt文件中的数据

private static void test4() throws Exception {
	//1):创建源或者目标对象
	File src = new File("file/result2.txt");
	//2):创建IO流对象
	FileReader in = new FileReader(src);
	//3):具体的IO操作
	System.out.println(in.read());//读取辛字符
	System.out.println(in.read());//读取弃字符
	System.out.println(in.read());//读取疾字符
	char[] buff = new char[5];//准备容量为5的缓冲区
	int len = in.read(buff);//读取5个字符数据,并存储到buff数组中
	System.out.println(Arrays.toString(buff));//[众, 里, 寻, 他, 千]
	System.out.println(len);//返回读取了几个字节
	//4):关闭资源(勿忘)
	in.close();
}

##字节流和字符流选用问题
使用记事本打开某个文件，如果可以看到内容的就是文本文件，否则可以暂时认为是二进制格式的。
一般的，操作二进制文件（图片、音频、视频等）必须使用字节流。操作文本文件使用字符流，尤其是操作带有中文的文件，使用字符流不容易导致乱码，因为使用字节流可能出现读取半个汉字的尴尬（汉字由两个或三个字节组成）。当然，如果不清楚属于哪一类型文件，都可以使用字节流。

JavaIO流常见使用方式

文件拷贝操作

需求：把copy_before.txt文件中的数据拷贝到copy_after.txt文件中

private static void copy() throws Exception {

    //1):创建源或者目标对象

    File src = new File("file/copy_before.txt");

    File dest = new File("file/copy_after.txt");

    //2):创建IO流对象

    FileReader in = new FileReader(src);

    FileWriter out = new FileWriter(dest);

    //3):具体的IO操作

    int len = -1;//记录以及读取了多个字符

    char[] buff = new char[1024];//每次可以读取1024个字符

    len = in.read(buff);//先读取一次

    while(len > 0) {

        //边读边写

        out.write(buff, 0, len);

        len = in.read(buff);//再继续读取

    }
    
    //4):关闭资源(勿忘)

    out.close();

    in.close();

}

如何，正确处理异常：

private static void copy2() {

    //1):创建源或者目标对象

    File src = new File("file/copy_before.txt");

    File dest = new File("file/copy_after.txt");

    //把需要关闭的资源，声明在try之外

    FileReader in = null;

    FileWriter out = null;

    try {

        //可能出现异常的代码

        //2):创建IO流对象

        in = new FileReader(src);

        out = new FileWriter(dest);

        //3):具体的IO操作

        int len = -1;//记录以及读取了多个字符

        char[] buff = new char[1024];//每次可以读取1024个字符

        len = in.read(buff);//先读取一次

        while (len > 0) {

            out.write(buff, 0, len);

            len = in.read(buff);//再继续读取

        }

    } catch (Exception e) {

        e.printStackTrace();

    } finally {

        //4):关闭资源(勿忘)

        try {

            if (out != null) {

                out.close();
            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        try {

            if (in != null) {

                in.close();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

此时关闭资源的代码，又臭又长，在后续的学习中为了方便就直接使用throws抛出IO异常了，在实际开发中需要处理。

缓冲流

节点流的功能都比较单一，性能较低。处理流，也称之为包装流，相对于节点流更高级，这里存在一个设计模式——装饰设计模式，此时撇开不谈。

包装流如何区分？写代码的时候，发现创建流对象时，需要传递另一个流对象，类似：

   new  流类A(  new 流类B(..));  

那么流A就属于包装流，当然B可能属于节点流也可能属于包装流。

有了包装流之后，我们只关系包装流的操作即可，比如只需要关闭包装流即可，无需在关闭节点流。

非常重要的包装流——缓冲流，根据四大基流都有各自的包装流：

BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

缓冲流内置了一个默认大小为8192个字节或字符的缓存区，缓冲区的作用用来减少磁盘的IO操作，拿字节缓冲流举例，比如一次性读取8192个字节到内存中，或者存满8192个字节再输出到磁盘中。

操作数据量比较大的流，都建议使用上对应的缓存流。

需求：把郭德纲-报菜名.mp3文件中的数据拷贝到郭德纲-报菜名2.mp3文件中

private static void copy3() throws Exception {

    //1):创建源或者目标对象

    File src = new File("file/郭德纲-报菜名.mp3");

    File dest = new File("file/郭德纲-报菜名2.mp3");

    //2):创建IO流对象

    BufferedInputStream bis =

        new BufferedInputStream(new FileInputStream(src), 8192);

    BufferedOutputStream bos =

        new BufferedOutputStream(new FileOutputStream(dest), 8192);

    //3):具体的IO操作

    int len = -1;//记录以及读取了多个字符

    byte[] buff = new byte[1024];//每次可以读取1024个字符

    len = bis.read(buff);//先读取一次

    while (len > 0) {

        //边读边写

        bos.write(buff, 0, len);

        len = bis.read(buff);//再继续读取

    }

    //4):关闭资源(勿忘)

    bos.close();

    bis.close();

}

对象序列化

序列化：指把Java堆内存中的对象数据，通过某种方式把对象数据存储到磁盘文件中或者传递给给网络上传输。序列化在分布式系统在应用非常广泛。

反序列化：把磁盘文件中的对象的数据或者把网络节点上的对象数据恢复成Java对象的过程。

需要做序列化的类必须实现序列化接口：java.io.Serializable（这是标志接口[没有抽象方法]）

可以通过IO中的对象流来做序列化和反序列化操作。

• ObjectOutputStream：通过writeObject方法做序列化操作的

• ObjectInputStream：通过readObject方法做反序列化操作的

如果字段使用transient 修饰则不会被序列化。

class User implements **Serializable** {

    private String name;

    private transient String password;

    private int age;

    public User(String name, String password, int age) {

        this.name = name;

        this.password = password;

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public String getPassword() {

        return password;

    }

    public int getAge() {

        return age;

    }

    public String toString() {

        return "User [name=" + name + ", password=" + password + ", age=" + age + "]";

    }

}

测试代码

public class ObjectStreamDemo {

    public static void main(String[] args) throws Exception {

        String file = "file/obj.txt";

        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));

        User u = new User("Will", "1111", 17);

        out.writeObject(u);

        out.close();

        //--------------------------------------

        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));

        Object obj = in.readObject();

        in.close();

        System.out.println(obj);

    }

}

obj.txt文件

序列化的版本问题

当类实现Serializable接口后，在编译的时候就会根据字段生成一个缺省的serialVersionUID值，并在序列化操作时，写到序列化数据文件中。

但随着项目的升级系统的class文件也会升级(增加一个字段/删除一个字段)，此时再重新编译，对象的serialVersionUID值又会改变。那么在反序列化时，JVM会把对象数据数据中的serialVersionUID与本地字节码中的serialVersionUID进行比较，如果值不相同（意味着类的版本不同），那么报异常InvalidCastException，即：类版本不对应，不能进行反序列化。如果版本号相同，则可以进行反序列化。

为了避免代码版本升级而造成反序列化因版本不兼容而失败的问题，在开发中我们可以故意在类中提供一个固定的serialVersionUID值。

class User implements Serializable {

    private static final long serialVersionUID = 1L;

    //TODO

}

查漏补缺

打印流

打印流是一种特殊是输出流，可以输出任意类型的数据，比一般的输出流更好用。可以作为处理流包装一个平台的节点流使用，平时我们使用的System.out.println其实就是使用的打印流。

• PrintStream ：字节打印流

• PrintWriter ：字符打印流

打印流中的方法：

• 提供了print方法：打印不换行

• 提供了println方法：先打印，再换行

private static void test5() throws Exception {

    //1):创建源或者目标对象

    File dest = new File("file/result3.txt");

    //2):创建IO流对象

    PrintStream ps = new PrintStream(new FileOutputStream(dest));

    //3):具体的IO操作

    ps.println("Will");

    ps.println(17);

    ps.println("众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。");

    //4):关闭资源(勿忘),打印流可以不用关闭

}  

标准IO

标准的输入：通过键盘录入数据给程序

标准的输出：在屏幕上显示程序数据

在System类中有两个常量int和out分别就表示了标准流:

InputStream in  = System.in;

PrintStream out = System.out;

需求：做一个ECHO（回声）的小案例

public static void main(String[] args) throws Exception {

    Scanner sc = new Scanner(System.in);   //接受用户输入数据后敲回车

    while (sc.hasNextLine()) {  //判断用户是否输入一行数据

        String line = sc.nextLine();  //获取用户输入的数据

        System.out.println("ECHO:" + line);//显示用户输入的数据

    }

}

IO流小结

在开发中使用比较多的还是字节和字符流的读写操作，务必要非常熟练，再体会一下六字箴言（读进来，写出去），到底有何深意。

综合练习题：做一个统计代码行数的程序，扫描一个目录能统计出该目录中包括所有子目录中所有Java文件的行数，不统计空行。

若要获得最好的学习效果，需要配合对应教学视频一起学习。需要完整教学视频，请参看https://ke.qq.com/course/272077。