24_IO_第24天(转换流、缓冲流)_讲义

时间:2022-12-09 11:26:16

今日内容介绍
1、转换流
2、缓冲流

01转换流概述

* A: 转换流概述
    * a: 转换流概述
        * OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节
        * 将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去
    

02转换流_字符转字节的过程

24_IO_第24天(转换流、缓冲流)_讲义

03OutputStreamWriter写文本文件

* A: OutputStreamWriter写文本文件
    * a: OutputStreamWriter
        * java.io.OutputStreamWriter 继承Writer类
        * 就是一个字符输出流,写文本文件
        * write()字符,字符数组,字符串
        * 字符通向字节的桥梁,将字符流转字节流
        * OutputStreamWriter 使用方式
            * 构造方法:
                * OutputStreamWriter(OuputStream out)接收所有的字节输出流
                * 字节输出流:  FileOutputStream
                * OutputStreamWriter(OutputStream out, String charsetName)
                * String charsetName 传递编码表名字 GBK  UTF-8
        * OutputStreamWriter 有个子类,  FileWriter
    * b: 案例代码

            public class OutputStreamWriterDemo {
                public static void main(String[] args)throws IOException {
            //      writeGBK();
                    writeUTF();
                }
                /*
                 * 转换流对象OutputStreamWriter写文本
                 * 采用UTF-8编码表写入
                 */
                public static void writeUTF()throws IOException{
                    //创建字节输出流,绑定文件
                    FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
                    //创建转换流对象,构造方法保证字节输出流,并指定编码表是UTF-8
                    OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
                    osw.write("你好");
                    osw.close();
                }

                /*
                 * 转换流对象 OutputStreamWriter写文本
                 * 文本采用GBK的形式写入
                 */
                public static void writeGBK()throws IOException{
                    //创建字节输出流,绑定数据文件
                    FileOutputStream fos = new FileOutputStream("c:\\gbk.txt");
                    //创建转换流对象,构造方法,绑定字节输出流,使用GBK编码表
                    OutputStreamWriter osw = new OutputStreamWriter(fos);
                    //转换流写数据
                    osw.write("你好");

                    osw.close();
                }
            }

04转换流_字节转字符流过程

* A: 转换流_字节转字符流过程
    * a: InputStreamReader
        * java.io.InputStreamReader 继承 Reader
        * 字符输入流,读取文本文件
        * 字节流向字符的敲了,将字节流转字符流
        * 读取的方法:
            * read() 读取1个字符,读取字符数组
        * 技巧
            * OuputStreamWriter写了文件
            * InputStreamReader读取文件
        * OutputStreamWriter(OutputStream out)所有字节输出流
        * InputStreamReader(InputStream in) 接收所有的字节输入流
        * 可以传递的字节输入流: FileInputStream
        * InputStreamReader(InputStream in,String charsetName) 传递编码表的名字
    * b: 图解
        * 详见day24_source/转换流.JPG图片

05InputSteamReader读取文本文件

* A: InputSteamReader读取文本文件
    * a: 案例代码
        public class InputStreamReaderDemo {
            public static void main(String[] args) throws IOException {
        //      readGBK();
                readUTF();
            }
            /*
             *  转换流,InputSteamReader读取文本
             *  采用UTF-8编码表,读取文件utf
             */
            public static void readUTF()throws IOException{
                //创建自己输入流,传递文本文件
                FileInputStream fis = new FileInputStream("c:\\utf.txt");
                //创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
                InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
                char[] ch = new char[1024];
                int len = isr.read(ch);
                System.out.println(new String(ch,0,len));
                isr.close();
            }
            /*
             *  转换流,InputSteamReader读取文本
             *  采用系统默认编码表,读取GBK文件
             */
            public static void readGBK()throws IOException{
                //创建自己输入流,传递文本文件
                FileInputStream fis = new FileInputStream("c:\\gbk.txt");
                //创建转换流对象,构造方法,包装字节输入流
                InputStreamReader isr = new InputStreamReader(fis);
                char[] ch = new char[1024];
                int len = isr.read(ch);
                System.out.println(new String(ch,0,len));

                isr.close();
            }
        }

06转换流子类父类的区别

* A: 转换流子类父类的区别
    * a: 继承关系
        OutputStreamWriter:
            |--FileWriter:
        InputStreamReader:
            |--FileReader;
    * b: 区别
        * 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");
        

07缓冲流概述

* A: 缓冲流概述
    * a: 概述
        * 可提高IO流的读写速度
        * 分为字节缓冲流与字符缓冲流
            

08字节输出流缓冲流BufferedOutputStream

* A: 字节输出流缓冲流BufferedOutputStream
    * a: BufferedOutputStream
        * 字节输出流的缓冲流
        * java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率
        * BufferedOuputStream 继承 OutputStream
        * 方法,写入 write 字节,字节数组
        * 构造方法:
            * BufferedOuputStream(OuputStream out)
            * 可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率  

    * b: 案例代码
        public class BufferedOutputStreamDemo {
            public static void main(String[] args)throws IOException {
                //创建字节输出流,绑定文件
                //FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");
                //创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
                BufferedOutputStream bos = new
                        BufferedOutputStream(new FileOutputStream("c:\\buffer.txt"));

                bos.write(55);

                byte[] bytes = "HelloWorld".getBytes();

                bos.write(bytes);

                bos.write(bytes, 3, 2);

                bos.close();
            }
        }

09字节输入流缓冲流BufferedInputStream

* A: 字节输入流缓冲流BufferedInputStream
    * a: BufferedInputStream
        * 字节输入流的缓冲流
        * 继承InputStream,标准的字节输入流
        * 读取方法  read() 单个字节,字节数组
        * 构造方法:
            * BufferedInputStream(InputStream in)
            * 可以传递任意的字节输入流,传递是谁,就提高谁的效率
            * 可以传递的字节输入流 FileInputStream
    * b: 案例代码
        public class BufferedInputStreamDemo {
            public static void main(String[] args) throws IOException{
                //创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
                BufferedInputStream bis = new
                        BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
                byte[] bytes = new byte[10];
                int len = 0 ;
                while((len = bis.read(bytes))!=-1){
                    System.out.print(new String(bytes,0,len));
                }
                bis.close();
            }
        }

10四种文件复制方式的效率比较

* A:四种文件复制方式的效率比较
    * a: 四中复制方式
        * 字节流读写单个字节                    125250 毫秒
        * 字节流读写字节数组                    193    毫秒  OK
        * 字节流缓冲区流读写单个字节         1210   毫秒
        * 字节流缓冲区流读写字节数组            73     毫秒  OK        

    * b: 案例代码

        public class Copy {
            public static void main(String[] args)throws IOException {
                long s = System.currentTimeMillis();
                copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
                long e = System.currentTimeMillis();
                System.out.println(e-s);
            }
            /*
             * 方法,实现文件复制
             *  4. 字节流缓冲区流读写字节数组
             */
            public static void copy_4(File src,File desc)throws IOException{
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
                int len = 0 ;
                byte[] bytes = new byte[1024];
                while((len = bis.read(bytes))!=-1){
                    bos.write(bytes,0,len);
                }
                bos.close();
                bis.close();
            }
            /*
             * 方法,实现文件复制
             *  3. 字节流缓冲区流读写单个字节
             */
            public static void copy_3(File src,File desc)throws IOException{
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
                int len = 0 ;
                while((len = bis.read())!=-1){
                    bos.write(len);
                }
                bos.close();
                bis.close();
            }

            /*
             * 方法,实现文件复制
             *  2. 字节流读写字节数组
             */
            public static void copy_2(File src,File desc)throws IOException{
                FileInputStream fis = new FileInputStream(src);
                FileOutputStream fos = new FileOutputStream(desc);
                int len = 0 ;
                byte[] bytes = new byte[1024];
                while((len = fis.read(bytes))!=-1){
                    fos.write(bytes,0,len);
                }
                fos.close();
                fis.close();
            }

            /*
             * 方法,实现文件复制
             *  1. 字节流读写单个字节
             */
            public static void copy_1(File src,File desc)throws IOException{
                FileInputStream fis = new FileInputStream(src);
                FileOutputStream fos = new FileOutputStream(desc);
                int len = 0 ;
                while((len = fis.read())!=-1){
                    fos.write(len);
                }
                fos.close();
                fis.close();
            }
        }

11字符输出流缓冲流BufferedWriter

* A: 字符输出流缓冲流BufferedWriter
    * a: BufferedWriter
        * 字符输出流缓冲区流
        * java.io.BufferedWriter 继承 Writer
        * 写入方法 write () 单个字符,字符数组,字符串

        * 构造方法:
            * BufferedWriter(Writer w)传递任意字符输出流
            * 传递谁,就高效谁
            * 能传递的字符输出流 FileWriter, OutputStreamWriter
    * b: 案例代码
        public class BufferedWrierDemo {
            public static void main(String[] args) throws IOException{
                //创建字符输出流,封装文件
                FileWriter fw = new FileWriter("c:\\buffer.txt");
                BufferedWriter bfw = new BufferedWriter(fw);

                bfw.write(100);
                bfw.flush();
                bfw.write("你好".toCharArray());
                bfw.flush();

                bfw.write("你好");

                bfw.flush();

                bfw.write("我好好");

                bfw.flush();

                bfw.write("大家都好");
                bfw.flush();

                bfw.close();

            }
        }

12字符输出流缓冲流BufferedWriter特有方法newLine

* A: 字符输出流缓冲流BufferedWriter特有方法newLine
    * a: 方法介绍
        * void  newLine() 写换行

        * newLine()文本中换行, \r\n也是文本换行
        * 方法具有平台无关性
        * Windows  \r\n
        * Linux    \n

        * newLine()运行结果,和操作系统是相互关系
        * JVM: 安装的是Windows版本,newLine()写的就是\r\n
        * 安装的是Linux版本,newLine()写的就是\n
        /*
         *  将数据源 c:\\a.txt
         *  复制到 d:\\a.txt  数据目的
         *  字节输入流,绑定数据源
         *  字节输出流,绑定数据目的
         *
         *  输入,读取1个字节
         *  输出,写1个字节
         */
    * b: 案例代码
        public class BufferedWrierDemo {
            public static void main(String[] args) throws IOException{
                //创建字符输出流,封装文件
                FileWriter fw = new FileWriter("c:\\buffer.txt");
                BufferedWriter bfw = new BufferedWriter(fw);

                bfw.write(100);
                bfw.flush();
                bfw.write("你好".toCharArray());
                bfw.flush();

                bfw.write("你好");
                bfw.newLine();
                bfw.flush();

                bfw.write("我好好");
                bfw.newLine();
                bfw.flush();

                bfw.write("大家都好");
                bfw.flush();

                bfw.close();

            }
        }

13字符输入流缓冲流BufferedReader

* A: 字符输入流缓冲流BufferedReader
    * a: 概述
        * 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取
        * public String readLine() 读取一个文本行,包含该行内容的字符串,
        * 不包含任何行终止符,如果已到达流末尾,则返回 null
            

14字符输入流缓冲流BufferedReader读取文本行

* A: 字符输入流缓冲流BufferedReader读取文本行
    * a: BufferedReader
        * 字符输入流缓冲流
        * java.io.BufferedReader 继承 Reader
        * 读取功能 read() 单个字符,字符数组
        * 构造方法:
            * BufferedReader(Reader r)
            * 可以任意的字符输入流
               FileReader  InputStreamReader
        * BufferedReader自己的功能
            * String readLine() 读取文本行 \r\n
                * 方法读取到流末尾,返回null
    * b: 小特点
         * 获取内容的方法一般都有返回值
         * int 没有返回的都是负数
         * 引用类型 找不到返回null
         * boolean 找不到返回false

    * c: 案例代码
        public class BufferedReaderDemo {
            public static void main(String[] args) throws IOException {
                int lineNumber = 0;
                //创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
                BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
                //调用缓冲流的方法 readLine()读取文本行
                //循环读取文本行, 结束条件 readLine()返回null
                String line = null;
                while((line = bfr.readLine())!=null){
                    lineNumber++;
                    System.out.println(lineNumber+"  "+line);
                }
                bfr.close();
            }
        }

        /*
         * String line = bfr.readLine();
                System.out.println(line);

                line = bfr.readLine();
                System.out.println(line);

                line = bfr.readLine();
                System.out.println(line);

                line = bfr.readLine();
                System.out.println(line);

                line = bfr.readLine();
                System.out.println(line);
         */
         

15字符流缓冲区流复制文本文件

* A: 字符流缓冲区流复制文本文件
    * a: 案例代码
        /*
         *  使用缓冲区流对象,复制文本文件
         *  数据源  BufferedReader+FileReader 读取
         *  数据目的 BufferedWriter+FileWriter 写入
         *  读取文本行, 读一行,写一行,写换行
         */
        public class Copy_1 {
            public static void main(String[] args) throws IOException{
                BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));
                BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
                //读取文本行, 读一行,写一行,写换行
                String line = null;
                while((line = bfr.readLine())!=null){
                    bfw.write(line);
                    bfw.newLine();
                    bfw.flush();
                }
                bfw.close();
                bfr.close();
            }
        }

16IO流对象的操作规律

* A: IO流对象的操作规律
    * a: 明确一:要操作的数据是数据源还是数据目的。
        * 源:InputStream    Reader
        * 目的:OutputStream Writer
        * 先根据需求明确要读,还是要写。

    * b: 明确二:要操作的数据是字节还是文本呢?
        * 源:
            * 字节:InputStream
            * 文本:Reader
        * 目的:
            * 字节:OutputStream
            * 文本:Writer
    * c: 明确三:明确数据所在的具体设备。
        * 源设备:
            * 硬盘:文件  File开头。
            * 内存:数组,字符串。
            * 键盘:System.in;
            * 网络:Socket
        * 目的设备:
            * 硬盘:文件  File开头。
            * 内存:数组,字符串。
            * 屏幕:System.out
            * 网络:Socket
            * 完全可以明确具体要使用哪个流对象。
    * d: 明确四:是否需要额外功能呢?
        * 额外功能:
            * 转换吗?转换流。InputStreamReader OutputStreamWriter
            * 高效吗?缓冲区对象。BufferedXXX
            * 已经明确到了具体的体系上。
            * 

作业测试

1.将前面作业中关于文件拷贝的操作,替换为高效流

  1. 用代码实现以下需求
(1)有如下字符串"If you want to change your fate I think you must come to the
    dark horse to learn java"(用空格间隔)
(2)打印格式:
    to=3
    think=1
    you=2
    //........
(3)按照上面的打印格式将内容写入到D:\\count.txt文件中(要求用高效流)

3.利用转换流将GBK格式文件以UTF-8输出

4.java写一个程序,实现从文件中读出文件内容,并将其打印在屏幕当中,并标注上行号

如果想进一步的交流,可以加入我们的QQ群,里面有最新的学习资料,可以学习。

24_IO_第24天(转换流、缓冲流)_讲义

24_IO_第24天(转换流、缓冲流)_讲义的更多相关文章

  1. Java基础知识强化之IO流笔记41:字符流缓冲流之复制文本文件案例02(使用 [ newLine() / readLine() ] )(重要)

    1. 使用字符流缓冲流的特殊功能 [ newLine() / readLine() ] 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中  数据源: a.txt -- 读取数据 ...

  2. Java基础知识强化之IO流笔记39:字符流缓冲流之复制文本文件案例01

    1. 字符流缓冲流之复制文本文件案例 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 数据源: a.txt -- 读取数据 -- 字符转换流 -- InputStreamRe ...

  3. IO流(字节流,字符流,缓冲流)

    一:IO流的分类(组织架构) 根据处理数据类型的不同分为:字节流和字符流 根据数据流向不同分为:输入流和输出流   这么庞大的体系里面,常用的就那么几个,我们把它们抽取出来,如下图:   二:字符字节 ...

  4. Java基础知识强化之IO流笔记38:字符流缓冲流之BufferedWriter / BufferedReader使用

    1. 字符流缓冲流: 字符流为了高效读写,也提供了对应的字符缓冲流. BufferedWriter:字符缓冲输出流 BufferedReader:字符缓冲输入流 2. BufferedWriter使用 ...

  5. -1-4 java io java流 常用流 分类 File类 文件 字节流 字符流 缓冲流 内存操作流 合并序列流

      File类 •文件和目录路径名的抽象表示形式 构造方法 •public File(String pathname) •public File(String parent,Stringchild) ...

  6. Java基础知识强化之IO流笔记40:字符流缓冲流之特殊功能 [ newLine() / readLine() ]

    1. 字符缓冲流的特殊方法 BufferedWriter: public void newLine():根据系统来决定换行符 BufferedReader: public String readLin ...

  7. java 文件字节和字符流 缓冲流

    流的原理 1) 在 Java 程序中,对于数据的输入/输出操作以“流”(stream) 方式进行:2) J2SDK 提供了各种各样的“流”类,用以获取不同种类的数据:程序中通过标准的方法输入或输出数据 ...

  8. io流-缓冲流

    单独去数据时,数据按块读入缓冲区,其后的操作则直接访问缓冲区 但是用 BufferedInputStream读取字节文件时,

  9. Java自学第10期——File类与IO流(输入输出流、处理流、转换流、缓冲流、Properties集合、打印流)

    1.IO简介 IO(输入输出)通过java.io包下的类和接口来支持,包下包括输入.输出两种IO流,每种输入输出流又可分为字符流和字节流两大类. 2.File类 File类是io包下与平台无关的文件和 ...

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

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

随机推荐

  1. 网页mp3语音展示,点击图片放大,点击图片跳转链接,调表格

    查看mp3语音 <td class="value"><embed src="${sounds.soundName}" type="a ...

  2. 使用Location对象查询字符串参数

    location是BOM中最有用的对象之一: 1.它提供了与当前窗口中加载的文档有关的信息: 2.他还提供了一些导航功能. location对象的属性有: hash, host, hostname, ...

  3. 有关c&num;装箱和拆箱知识整理

    c#装箱和拆箱知识,装箱和拆箱是一个抽象的概念. 1.装箱和拆箱是一个抽象的概念  2.装箱是将值类型转换为引用类型 : 拆箱是将引用类型转换为值类型 利用装箱和拆箱功能,可通过允许值类型的任何值与O ...

  4. Hyperion Essbase BusinessRule 函数学习--2

    @AVG Returns the average of all values in expList. [返回表达式列表的平均值] Syntax @AVG (SKIPNONE | SKIPMISSING ...

  5. UNIX网络编程——TCP—经受时延与nagle算法、滑动窗口、拥塞窗口

    1.经受时延: TCP在接收到数据时并不立即发送ACK,相反,它推迟发送,以便将ACK与需要沿该方向发送的数据一起发送,时延为200ms,超过时延范围,发送确认. 2.nagle算法: 一个TCP连接 ...

  6. 软件工程 week 04

    四则运算 一.摘要 作业地址:https://edu.cnblogs.com/campus/nenu/2016CS/homework/2266 git仓库地址:https://git.coding.n ...

  7. Shell基础知识(三)

    Shell中变量的作用域: 在当前Shell会话中使用,全局变量. 在函数内部使用,局部变量. 可以在其他Shell会话中使用,环境变量. 局部变量: 默认情况下函数内的变量也是全局变量 #!/bin ...

  8. 12C新特性 -- 共享asm口令文件

    12C中,ASM口令文件,可以提供本地.远程登录asm的验证.当然,要想使用asm口令文件验证,必须为每个asm创建一个口令文件. 如果是使用asm存储,asmca在配置asm磁盘组的会后,会自动为a ...

  9. Vultr VPS建站攻略 – 一键安装宝塔面板架设LNMP&sol;LAMP Web环境

    我们选择VULTR VPS建站的还是比较多的,其主要原因在于商家的稳定,毕竟我们用来建站选择服务器价格考虑的不是主要的(当然VULTR价格也是比较便宜),最为主要的是因为VULTR商家比较稳定,而且多 ...

  10. Redis-用思维导图二天搞定Redis用法。

    Redis整体面貌 Redis基本数据结构 1.String 1.1 数据结构 long len byte数组长度 long free 可用数组长度 char buff[] 数据内容 1.2 命令 键 ...