今日内容介绍

  • 转换流
  • 缓冲流

    1 转换流

在学习字符流(FileReader、FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStreamWriter,这又是什么意思呢?

OutputStreamWriter类

查阅OutputStreamWriter的API介绍,OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节。它的作用的就是,将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去。

  • 代码演示:
public static void writeCN() throws Exception {

        //创建与文件关联的字节输出流对象

        FileOutputStream fos = new FileOutputStream("c:\\cn8.txt");

        //创建可以把字符转成字节的转换流对象,并指定编码

        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");

        //调用转换流,把文字写出去,其实是写到转换流的缓冲区中

        osw.write("你好");//写入缓冲区。

        osw.close();

    }

OutputStreamWriter流对象,它到底如何把字符转成字节输出的呢?

其实在OutputStreamWriter流中维护自己的缓冲区,当我们调用OutputStreamWriter对象的write方法时,会拿着字符到指定的码表中进行查询,把查到的字符编码值转成字节数存放到OutputStreamWriter缓冲区中。然后再调用刷新功能,或者关闭流,或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中。

InputStreamReader类

查阅InputStreamReader的API介绍,InputStreamReader 是字节流通向字符流的桥梁:它使用指定的字符编码表读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定,或者可以接受平台默认的字符集。

  • 代码演示
public class InputStreamReaderDemo {

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

        //演示字节转字符流的转换流

        readCN();

    }

    public static void readCN() throws IOException{

        //创建读取文件的字节流对象

        InputStream in = new FileInputStream("c:\\cn8.txt");

        //创建转换流对象

        //InputStreamReader isr = new InputStreamReader(in);这样创建对象,会用本地默认码表读取,将会发生错误解码的错误

InputStreamReader isr = new InputStreamReader(in,"utf-8");

        //使用转换流去读字节流中的字节

        int ch = 0;

        while((ch = isr.read())!=-1){

            System.out.println((char)ch);

        }

        //关闭流

        isr.close();

    }

}

注意:在读取指定的编码的文件时,一定要指定编码格式,否则就会发生解码错误,而发生乱码现象。

转换流和子类区别

发现有如下继承关系:

OutputStreamWriter:

|--FileWriter:

InputStreamReader:

|--FileReader;

父类和子类的功能有什么区别呢?

OutputStreamWriter和InputStreamReader是字符和字节的桥梁:也可以称之为字符转换流。字符转换流原理:字节流+编码表。

FileWriter和FileReader:作为子类,仅作为操作字符文件的便捷类存在。当操作的字符文件,使用的是默认编码表时可以不用父类,而直接用子类就完成操作了,简化了代码。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

FileReader fr = new FileReader("a.txt");

这三句代码的功能是一样的,其中第三句最为便捷。

注意:一旦要指定其他编码时,绝对不能用子类,必须使用字符转换流。什么时候用子类呢?

条件:

1、操作的是文件。2、使用默认编码。

总结:

字节--->字符 : 看不懂的--->看的懂的。 需要读。输入流。 InputStreamReader

字符--->字节 : 看的懂的--->看不懂的。 需要写。输出流。 OutputStreamWriter

2 缓冲流

在我们学习字节流与字符流的时候,大家都进行过读取文件中数据的操作,读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率,那么,我想提高速度,怎么办?

Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度

缓冲流,根据流的分类分类字节缓冲流与字符缓冲流。

字节缓冲流

字节缓冲流根据流的方向,共有2个

  • 写入数据到流中,字节缓冲输出流 BufferedOutputStream
  • 读取流中的数据,字节缓冲输入流 BufferedInputStream

    它们的内部都包含了一个缓冲区,通过缓冲区读写,就可以提高了IO流的读写速度

字节缓冲输出流BufferedOutputStream

通过字节缓冲流,进行文件的读写操作 写数据到文件的操作

  • 构造方法

    public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流,以将数据写入指定的底层输出流。

public class BufferedOutputStreamDemo01 {

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

        //写数据到文件的方法

        write();

    }

    /*

     * 写数据到文件的方法

     * 1,创建流

     * 2,写数据

     * 3,关闭流

     */

    private static void write() throws IOException {

        //创建基本的字节输出流

        FileOutputStream fileOut = new FileOutputStream("abc.txt");

        //使用高效的流,把基本的流进行封装,实现速度的提升

        BufferedOutputStream out = new BufferedOutputStream(fileOut);

        //2,写数据

        out.write("hello".getBytes());

        //3,关闭流

        out.close();

    }

}

字节缓冲输入流 BufferedInputStream

刚刚我们学习了输出流实现了向文件中写数据的操作,那么,现在我们完成读取文件中数据的操作

  • 构造方法

    public BufferedInputStream(InputStream in)

 /*

     * 从文件中读取数据

     * 1,创建缓冲流对象

     * 2,读数据,打印

     * 3,关闭

     */

    private static void read() throws IOException {

        //1,创建缓冲流对象

        FileInputStream fileIn = new FileInputStream("abc.txt");

        //把基本的流包装成高效的流

        BufferedInputStream in = new BufferedInputStream(fileIn);

        //2,读数据

        int ch = -1;

        while ( (ch = in.read()) != -1 ) {

            //打印

            System.out.print((char)ch);

        }

        //3,关闭

        in.close();

    }

使用基本的流与高效的流完成复制文件

我们一直在说,高效的流速度快并高效,怎么体现呢?需要通过一个复制文件耗时的比较过程,来体验一下高效流带来的快感。

/*

* 需求:将d:\\test.avi文件进行复制

*         采用4种方式复制

*         方式1:采用基本的流,一次一个字节的方式复制    共耗时 224613毫秒

*         方式2:采用基本的流,一个多个字节的方式赋值    共耗时 327毫秒

*         方式3:采用高效的流,一次一个字节的方式复制    共耗时 2047毫秒

*         方式4:采用高效的流,一个多个字节的方式赋值    共耗时 96毫秒

*

* 数据源: d:\\test.avi

* 目的地1: d:\\copy1.avi

* 目的地2: d:\\copy2.avi

* 目的地3: d:\\copy3.avi

* 目的地4: d:\\copy4.avi

*

* 实现的步骤:

*     1,指定数据源

*     2,指定目的地

*     3,读数据

*     4,写数据

*     5,关闭流

*

*/

public class CopyAVI {

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

        //开始计时

        long start = System.currentTimeMillis();

        //方式1:采用基本的流,一次一个字节的方式复制

        //method1("d:\\test.avi", "d:\\copy1.avi");

        //方式2:采用基本的流,一个多个字节的方式赋值

        //method2("d:\\test.avi", "d:\\copy2.avi");

        //方式3:采用高效的流,一次一个字节的方式复制

        //method3("d:\\test.avi", "d:\\copy3.avi");

        //方式4:采用高效的流,一个多个字节的方式赋值

        method4("d:\\test.avi", "d:\\copy4.avi");

        //结束计时

        long end = System.currentTimeMillis();

        //打印耗时多少毫秒

        System.out.println("共耗时 " +(end - start)+ "毫秒");

    }

    //方式4:采用高效的流,一个多个字节的方式赋值

    private static void method4(String src, String dest) throws IOException {

        //1,指定数据源

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

         //2,指定目的地

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

         //3,读数据

        byte[] buffer = new byte[1024];

        int len = -1;

        while ( (len = in.read(buffer)) != -1) {

            //4,写数据

            out.write(buffer, 0, len);

        }

         //5,关闭流

        in.close();

        out.close();

    }

    //方式3:采用高效的流,一次一个字节的方式复制

    private static void method3(String src, String dest) throws IOException {

        //1,指定数据源

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

         //2,指定目的地

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

         //3,读数据

        int ch = -1;

        while ((ch=in.read()) != -1) {

            //4,写数据

            out.write(ch);    

        }        

         //5,关闭流

        in.close();

        out.close();

    }

    //方式2:采用基本的流,一个多个字节的方式赋值

    private static void method2(String src, String dest) throws IOException {

        //1,指定数据源

        FileInputStream in = new FileInputStream(src);

        //2,指定目的地

        FileOutputStream out = new FileOutputStream(dest);

        //3,读数据

        byte[] buffer = new byte[1024];

        int len = -1;

        while ( (len=in.read(buffer)) != -1) {

            //4,写数据

            out.write(buffer, 0, len);

        }

        //5,关闭流

        in.close();

        out.close();

    }

    //方式1:采用基本的流,一次一个字节的方式复制

    private static void method1(String src, String dest) throws IOException {

        //1,指定数据源

        FileInputStream in = new FileInputStream(src);

        //2,指定目的地

        FileOutputStream out = new FileOutputStream(dest);

        //3,读数据

        int ch = -1;

        while (( ch=in.read()) != -1) {

            //4,写数据

            out.write(ch);

        }

        //5,关闭流

        in.close();

        out.close();

    }

}

字符缓冲流

  • 字符缓冲输入流 BufferedReader
  • 字符缓冲输出流 BufferedWriter

完成文本数据的高效的写入与读取的操作

字符缓冲输出流 BufferedWriter

将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

  • 方法:

        void newLine() 根据当前的系统,写入一个换行符

/*

* BufferedWriter 字符缓冲输出流

* 方法

*     public void newLine()写入一个行分隔符

*

* 需求:通过缓冲输出流写入数据到文件

* 分析:

*     1,创建流对象

*     2,写数据

*     3,关闭流

*

*/

public class BufferedWriterDemo {

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

        //创建流

        //基本字符输出流

        FileWriter fileOut = new FileWriter("file.txt");

        //把基本的流进行包装

        BufferedWriter out = new BufferedWriter(fileOut);

        //2,写数据

        for (int i=0; i<5; i++) {

            out.write("hello");

            out.newLine();

        }

        //3,关闭流

        out.close();

    }

}

字符缓冲输入流 BufferedReader

从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

  • 方法

        public String readLine() 读取一个文本行,包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

/*

* BufferedReader 字符缓冲输入流

*

* 方法:

*     String readLine()

* 需求:从文件中读取数据,并显示数据

*/

public class BufferedReaderDemo {

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

        //1,创建流

        BufferedReader in = new BufferedReader(new FileReader("file.txt"));

        //2,读数据

        //一次一个字符

        //一次一个字符数组

        //一次读取文本中一行的字符串内容

        String line = null;

        while( (line = in.readLine()) != null ){

            System.out.println(line);

        }

        //3,关闭流

        in.close();

    }

}

使用字符缓冲流完成文本文件的复制

刚刚我们学习完了缓冲流,现在我们就使用字符缓冲流的特有功能,完成文本文件的复制

/*

* 采用高效的字符缓冲流,完成文本文件的赋值

*

* 数据源: file.txt

* 目的地: copyFile.txt

*

* 分析:

*     1,指定数据源,是数据源中读数据,采用输入流

*     2,指定目的地,是把数据写入目的地,采用输出流

*     3,读数据

*     4,写数据

*     5,关闭流

*/

public class CopyTextFile {

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

        //1,指定数据源,是数据源中读数据,采用输入流

        BufferedReader in = new BufferedReader(new FileReader("file.txt"));

        //2,指定目的地,是把数据写入目的地,采用输出流

        BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));

        //3,读数据

        String line = null;

        while ( (line = in.readLine()) != null ) {

            //4,写数据

            out.write(line);

            //写入换行符号

            out.newLine();

        }

        //5,关闭流

        out.close();

        in.close();

    }

}

流的操作规律

IO流中对象很多,解决问题(处理设备上的数据时)到底该用哪个对象呢?  

把IO流进行了规律的总结(四个明确):

  • 明确一:要操作的数据是数据源还是数据目的。

源:InputStream Reader

目的:OutputStream Writer

先根据需求明确要读,还是要写。

  • 明确二:要操作的数据是字节还是文本呢?

源:

字节:InputStream

文本:Reader

目的:

字节:OutputStream

文本:Writer

已经明确到了具体的体系上。

  • 明确三:明确数据所在的具体设备。

源设备:

硬盘:文件 File开头。

内存:数组,字符串。

键盘:System.in;

网络:Socket

目的设备:

硬盘:文件 File开头。

内存:数组,字符串。

屏幕:System.out

网络:Socket

完全可以明确具体要使用哪个流对象。

  • 明确四:是否需要额外功能呢?

额外功能:

转换吗?转换流。InputStreamReader OutputStreamWriter

高效吗?缓冲区对象。BufferedXXX

InputStream

FileInputStream

BufferedInputStream

OuputStream

FileOutputStream

BufferedOuputStream

Writer

OutputStreamWriter

FileWriter

BufferedWriter

Reader

InputStreamReader

FileReader

BufferedReader

3 总结

知识点总结

  • 字节流
    • 字节输入流 InputStream
      • FileInputStream 操作文件的字节输入流
      • BufferedInputStream高效的字节输入流
    • 字节输出流 OutputStream
      • FileOutputStream 操作文件的字节输出流
      • BufferedOutputStream 高效的字节输出流
  • 字符流
    • 字符输入流 Reader
      • FileReader 操作文件的字符输入流
      • BufferedReader 高效的字符输入流
      • InputStreamReader 输入操作的转换流(把字节流封装成字符流)
    • 字符输出流 Writer
      • FileWriter 操作文件的字符输出流
      • BufferedWriter 高效的字符输出流
      • OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)
  • 方法:
    • 读数据方法:
      • read() 一次读一个字节或字符的方法
      • read(byte[] char[]) 一次读一个数组数据的方法
      • readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
      • readObject() 从流中读取对象(ObjectInputStream特有方法)
    • 写数据方法:
      • write(int) 一次写一个字节或字符到文件中
      • write(byte[] char[]) 一次写一个数组数据到文件中
      • write(String) 一次写一个字符串内容到文件中
      • writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
      • newLine() 写一个换行符号(BufferedWriter类特有方法)
  • 向文件中写入数据的过程

    1,创建输出流对象

    2,写数据到文件

    3,关闭输出流

  • 从文件中读数据的过程
  1. 创建输入流对象
  2. 从文件中读数据
  3. 关闭输入流
  • 文件复制的过程
  1. 创建输入流(数据源)
  2. 创建输出流(目的地)
  3. 从输入流中读数据
  4. 通过输出流,把数据写入目的地
  5. 关闭流

Java_转换流和缓冲流的更多相关文章

  1. Java转换流、缓冲流、流操作规律整理

    转换流 1.1                OutputStreamWriter类 OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字 ...

  2. IO流----转换流、缓冲流

    打开一个文本文件,另存为: Ansi就是系统默认编码(就是gbk) 建一个编码是utf-8的txt文件, 例: import java.io.FileWriter; import java.io.IO ...

  3. IO(转换流、缓冲流)

    第1章 转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者Output ...

  4. java基础(24):转换流、缓冲流

    1. 转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputS ...

  5. java:IO流(处理流(缓冲流,转换流,数据流),对象的序列化,Properties)

    字节缓冲流:(BufferedInputStream,BufferedOutStream) *按照流的功能来分:节点流和处理流 *节点流可以直接操作数据源: *InputStream *--FileI ...

  6. IO—》转换流和缓冲流

    转换流 摘要: InputStreamReader和OutputStreamWriter他们分别是FileReader和FileWriter的父类 当只是单纯的读写文件而不改变文件的编码格式时,就分别 ...

  7. java的 IO流之缓冲流(转载)

    java缓冲流本身不具IO功能,只是在别的流上加上缓冲提高效率,像是为别的流装上一种包装.当对文件或其他目标频繁读写或操作效率低,效能差.这时使用缓冲流能够更高效的读写信息.因为缓冲流先将数据缓存起来 ...

  8. IO流之缓冲流

    缓冲流 Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度 缓冲流,根据流的分类字节缓冲流与字符缓冲流. 字节缓冲流 字节缓冲流根据流的方向,共有2个 l  写入数据到流中,字节缓冲输出流 ...

  9. java - >IO流_缓冲流(高效流)

    缓冲流(高效流) 在我们学习字节流与字符流的时候,大家都进行过读取文件中数据的操作,读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率,那么,我想提高速度,怎么办? Java中提高了一套缓冲 ...

随机推荐

  1. Zookeeper详解-伪分布式和集群搭建(八)

    说到分布式开发Zookeeper是必须了解和掌握的,分布式消息服务kafka .hbase 到hadoop等分布式大数据处理都会用到Zookeeper,所以在此将Zookeeper作为基础来讲解. Z ...

  2. 深入理解Java虚拟机(字节码执行引擎)

    深入理解Java虚拟机(字节码执行引擎) 本文首发于微信公众号:BaronTalk 执行引擎是 Java 虚拟机最核心的组成部分之一.「虚拟机」是相对于「物理机」的概念,这两种机器都有代码执行的能力, ...

  3. 如何在虚拟环境里运行spyder?如解决import tensorflow as tf 出现importError:no module named 'tensorflow'

    问题描述:我们安装tensorflow时,通过activate tensorflow把tensorflow安装在虚拟环境里了,当我们在spyder里想要使用tensorflow时,就会发现如下图所以情 ...

  4. Linux基础及系统优化

    1 如何实现自动挂载操作(光驱自动挂载--fstab) 1.1 方法 第一种方法:编辑fstab文件 vi /etc/fstab /dev/cdrom /mnt iso9660 default 0 0 ...

  5. JVM 参数类型

    标准参数 -help -server -client -version -showversion -cp -classpath X参数 非标准化参数(在各个JDK版本中可能会变,但是变动比较小) -X ...

  6. Hive学习之路(二)—— Linux环境下Hive的安装部署

    一.安装Hive 1.1 下载并解压 下载所需版本的Hive,这里我下载版本为cdh5.15.2.下载地址:http://archive.cloudera.com/cdh5/cdh/5/ # 下载后进 ...

  7. Atlassian In Action - (Atlassian成长之路)

    Atlassian是我工作过程中,使用过的最满意的研发团队管理套装.使用的主要软件包括Jira Software,Confluence,Fisheye/Crucible.理论上还可以再加上Bitbuc ...

  8. Linux查看进程具体开启时间

    ps -p 2417 -o lstart -- 2417为进程号

  9. Event StoryLine Corpus 论文阅读

    Event StoryLine Corpus 论文阅读 本文是对 Caselli T, Vossen P. The event storyline corpus: A new benchmark fo ...

  10. 主机地址变更后,dubbo请求时依旧会寻址旧IP的问题

    机房迁移,导致测试服务器IP变更,比原于IP为192.168.1.105变更为10.1.9.120. 服务源码未做任何变更,启动服务时依旧是旧地址请求,此问题由dubbo本地注册中心的缓存所致,清理掉 ...