Java 基础(九)字符流

983 阅读8分钟

终于结束了集合的学习,今天我们就开始学习 I/O的操作了。 I/O 系列的内容分为 I/O概述、字符流、字节流。今天要学的是 I/O和字符流的操作

由于概述篇幅较短,所以就把概述压缩到这里来了。

I/O 概述

I/O:即 Input Output,输入输出的意思。

  • IO 流用来处理设备之间的数据传输。
  • JAVA 对数据的操作都是通过流的方式
  • JAVA 用于操作流的对象都在 IO 包里面
  • 流的操作分两种:字符流、字节流
  • 流的流向分两种:输入流、输出流

对数据的操作,其实就是对 File 文件。我偷了一张祖师爷传下来的图来描述 IO 流类结构关系。

从图中可以看出,都是从这以下四个类中派生出来的子类,子类的类型也好区分,后缀都是抽象基类名。

  • 字节流抽象基类
    • InputStream
    • OutputStream
  • 字符流抽象基类
    • Reader
    • Writer

IOException

IO 异常大致分为三种,一是 IO 异常、二是找不到文件异常、三是没有对象异常。

因此,我们在异常处理的时候,比较严峻的写法应该这样

FileWriter fileWriter = null;
try {
    fileWriter = new FileWriter("demo.txt");
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} finally {
    try {
        if (fileWriter != null) {
            fileWriter.close();
            }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

字符流-Reader/Writer

Reader 和 Writer的定义

Reader: 用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

Writer: 写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

字符流的读写FileReader 和 FileWriter。

先看看基本运用吧~

try {
        // 创建读取流和写入流
        FileReader fileReader = new FileReader("raw.txt");
        FileWriter fileWriter = new FileWriter("target.txt");
        // 读取单个字符,自动往下读
        int ch;
        while ((ch = fileReader.read()) != -1) {
            fileWriter.write(ch);
        }
            fileReader.close();
            fileWriter.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

每次读取一个字符再执行写入操作,效率比较慢,我们可以尝试一次读取更多的数据再一次性写入。

try {
        // 创建读取流和写入流
        FileReader fileReader = new FileReader("raw.txt");
        FileWriter fileWriter = new FileWriter("target.txt");
        // 读取1024个字符,自动往下读
        char[] buf = new char[1024];
        while (fileReader.read(buf) != -1) {
            fileWriter.write(buf);
        }
        fileReader.close();
        fileWriter.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

以上两种方法实现了文件的读写操作,将 raw.txt 读取写入 targer.txt 文件里面。

同时,这步操作也可以当成是文件的拷贝

需要注意的是:

  • 读取文件时,如果路径对应的文件不存在会报 IOException
  • 写入文件时,如果路径对应的文件不存在会自动在该目录下创建文件

如果要实现追加写入文件的操作,比如将 raw1.txt 和 raw2.txt 共同写入 target.txt 里面,只需要在创建 FileWriter 的时候使用两个参数的构造方法即可,如:FileWriter fileWriter = new FileWriter("target.txt",true);

至于源码读写的实现,我简单说一下吧。其实 FileReader/FileWriter 的构造方法里面都有 new FileInputStream/FileOutputStream 的对象,然后继承的是InputStreamReader/OutputStreamWriter.这说明啥,我想大家心里应该有数了吧,其实还是调用了字节流的读取,然后使用StreamEncoder/StreamDecoder进行编码解码操作。

具体流程是这样的,这里每次读/写太长了,我只说读取操作了,反正都是相对的。

  1. 首先创建 FileReader 对象,FileReader对象构造方法里面创建了FileInputStream。然后再使用 FileInputStream 作为参数,创建 StreamDecoder对象。
  2. 调用FileReader.read()读取一个字符,实际上就是调用了 StreamDecoder 同时读取两个字节,再使用这两个字节组成一个字符返回。

字符流的缓冲区

字符流的缓冲区,提高了对数据的读写效率,他有两个子类

  • BufferedWriter
  • BufferedReader

缓冲区要结合流才可以使用
在流的基础上对流的功能进行了增强

源码就不带着大家一起读了,我给大家分析一下 BufferedWriter 的思想。以下内容划重点,期末考试要考!

要想理解 BufferReader,就要先理解它的思想。BufferReader 的作用是为其它Reader 提供缓冲功能。创建BufferReader 时,我们会通过它的构造函数指定某个Reader 为参数。BufferReader 会将该Reader 中的数据分批读取,每次读取一部分到缓冲中;操作完缓冲中的这部分数据之后,再从Reader 中读取下一部分的数据。
为什么需要缓冲呢?原因很简单,效率问题!缓冲中的数据实际上是保存在内存中,而原始数据可能是保存在硬盘中;而我们知道,从内存中读取数据的速度比从硬盘读取数据的速度至少快10倍以上。
那干嘛不干脆一次性将全部数据都读取到缓冲中呢?第一,读取全部的数据所需要的时间可能会很长。第二,内存价格很贵,容量不想硬盘那么大。

通过字符流缓冲区来复制文件操作

还用上面那个案例

BufferedReader bufferedReader;
BufferedWriter bufferedWriter;
try {
    // 创建读取流和写入流
    bufferedReader = new BufferedReader(new FileReader("raw.txt"));
    bufferedWriter = new BufferedWriter(new FileWriter("target.txt", true));
    // 读取一行字符串
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        bufferedWriter.write(line);
    }
    bufferedReader.close();
    bufferedWriter.close();
} catch (IOException e) {
    e.printStackTrace();
}

没什么特别的,很简单

仿写一个 readLine

上文中,出现了一个 readLine 方法,可以一次读取一行字符串。
其实这个一次读取一行字符串还是蛮有用的,比如说读取一些Key-value 形式的配置文件。

我们来看看 JDK 中关于 readLine 的描述

读取一个文本行。通过下列字符之一即可认为某行已终止:换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
返回:包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null
抛出:IOException - 如果发生 I/O 错误

所以,我们自己要封装一个 readLine,只需要判断读取到的字符是否为'\n'、'\r',再一次性返回就行了。

class MyBufferReaderLine {

    private Reader fr;

    public MyBufferReaderLine(Reader fr) {
        this.fr = fr;
    }

    // 一次读取一行的方法
    public String readLine() throws IOException {

        // 定义临时容器
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while ((ch = fr.read()) != -1) {

            if (ch == '\r' || ch == '\n') {
                return sb.toString();
            } else {
                sb.append((char) ch);
            }
        }
        if(sb.length() != 0){
            return sb.toString();
        }
        return null;
    }

    public void close() throws IOException {
        fr.close();
    }
}

代码实现很简单,就是参考 BufferedReader 写的一个包装类。

LineNumberReader

你们先感受一下这个类的用法

FileReader fr;
try {
    fr = new FileReader("test.txt");
    LineNumberReader lnr = new LineNumberReader(fr);
    String line;
    while ((line = lnr.readLine()) != null) {
        System.out.println(lnr.getLineNumber() + ":" + line);
    }
    lnr.close();
} catch (IOException e) {
    e.printStackTrace();
}

这货和我们刚刚手写的MyBufferReaderLine 基本没啥区别,继承自BufferedReader ,然后多了一个lineNumber 属性,lineNumber用来记录当前行数。
实现没有什么意义,我们在MyBufferReaderLine 上添加一个字段lineNumber,每次 readLine 成功之后 lineNumber++ 即可。

但是,为什么要讲他呢,因为他和 BufferedReader 一样,也是一个包装类啊。

包装类就是装饰设计模式啊~

好了,你们都知道了,就是提一下装饰模式。

装饰模式

当想要对已有的对象进行功能增强时,可以定义一个类,将已有对象传入,并且提供加强功能,那么自定义的该类就称为装饰类。
装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案。

可能有的同学会问,那么为什么不用继承呢?我写一个新的类,继承、再添加扩展方法或者重写方法也可以实现呀。

假如咖啡厅卖咖啡,运营可一段时间,发现客户对咖啡的甜度有不同的需求,有如下三种需求加少量糖、一般糖、多糖。代码实现可以给 Coffee 添加一个糖量的属性,但是一开始设计 Coffee 这个类的时候没有加这个属性,根据开发守则,我们是不应该去修改原 Coffee 类,此时可以选择新增三个子类,LowSurgeCoffee、MidSurgeCoffee、HightSurgeCoffee,或者使用装饰模式,添加3个不同糖量的 SurgeDecorator。此时,使用装饰模式和继承没什么区别。但是运行了一段时间之后,需求又加了,咖啡需要新增口味卡布奇诺和摩卡。此时再组合之前的三种糖量,一共需要9个咖啡类。但是如果使用装饰模式,只需要新增摩卡和卡布奇诺装饰器就行了。一共6个装饰类。之后再扩展新的口味需要的子类是乘算,但是如果是装饰类,就只是加算。

以上这个例子没有代码实现,因为我懒。。。。。。

针对的问题:

动态地给一个对象添加一些额外的职责。就增加功能来说,Decorator模式相比生成子类更为灵活。不改变接口的前提下,增强所考虑的类的性能。

何时使用
  • 需要扩展一个类的功能,或给一个类增加附加责任。
  • 需要动态的给一个对象增加功能,这些功能可以再动态地撤销。
  • 需要增加一些基本功能的排列组合而产生的非常大量的功能,从而使继承变得不现实。
优缺点
  • 装饰者模式比继承要灵活,避免了继承体系的臃肿,而且降低了类与类之间的关系
  • 装饰类因为增强已有对象,具备功能和已有的想相同,只不过提供了更强的功能,所以装饰类和被装饰类通常属于一个体系中的