Java基础学习第一10贰天

明天内容介绍
1、转换流
2、缓冲流

0一调换流概述

* A: 转换流概述
    * a: 转换流概述
        * OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节
        * 将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去
文档版本 开发工具 测试平台 工程名字 日期 作者 备注
V1.0 2016.03.22 lutianfei none

0壹转换流概述

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

02转换流_字符转字节的长河

* A: 转换流_字符转字节的过程
    * a.图解
        * 详见day24_source/转换流.JPG图片

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

图片 1

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();
                }
            }

[TOC]

0三OutputStreamWriter写文本文件

* 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图片

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图片

0伍InputSteamReader读取文本文件

* 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();
            }
        }

调换流出现的缘故及思维

  • 由于字节流操作中文不是专程方便,所以,java就提供了转换流
  • 字符流 = 字节流 + 编码表

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();
            }
        }

0陆转换流子类父类的分别

* 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");

编码表

  • 字符会同相应的数值组合的一张表

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流的读写速度
        * 分为字节缓冲流与字符缓冲流 

常见编码表

  • Computer只好识别②进制数据,开始的一段时代由来是邮电通讯号。为了有利于利用Computer,让它能够辨别各种国家的文字。
  • ASCII:美利哥专门的职业消息交流码。
    • 用多个字节的八位能够表示。
  • ISO885九-一:拉丁码表。澳洲码表
    • 用三个字节的七位表示。
  • GB231二:中华夏族民共和国的华语编码表。
  • GBK:中中原人民共和国的国语编码表晋级,融入了更加多的中文文字标记。
  • GB18030:GBK的代表版本
  • BIG-伍码
    :通行于江苏、香江地区的3个繁体字编码方案,俗称“大五码”。
  • Unicode:国际规范码,融入了八种文字。
    • 富有文字都用八个字节来表示,Java语言使用的正是unicode
  • UTF-8:最多用四个字节来代表2个字符。
  • UTF-八区别,它定义了1种“区间规则”,这种规则能够和ASCII编码保持最大程度的相称:
    • 它将Unicode编码为00000000-0000007F的字符,用单个字节来表示
    • 它将Unicode编码为00000080-000007FF的字符用多个字节表示
    • 它将Unicode编码为00000800-0000FFFF的字符用三字节表示

07缓冲流概述

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

0八字节出口流缓冲流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();
            }
        }

字符串中的编码难点

  • 编码

    • byte[] getBytes(String
      charsetName):使用钦点的字符集结把字符串编码为字节数组
  • 解码

    • String(byte[] bytes, String
      charsetName):通过点名的字符集解码字节数组
  • 编码:把看得懂的形成看不懂的

    • String — byte[]
  • 解码:把看不懂的产生看得懂的

    • byte[] — String

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "你好";

        // String -- byte[]
        byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
        // byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
        // byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
        System.out.println(Arrays.toString(bys));

        // byte[] -- String
        String ss = new String(bys); // 你好
        // String ss = new String(bys, "GBK"); // 你好
        // String ss = new String(bys, "UTF-8"); // ???
        System.out.println(ss);
    }
}

0八字节出口流缓冲流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();
            }
        }

0九字节输入流缓冲流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();
            }
        }

转变流概述

  • OutputStreamWriter 字符输出流

    • OutputStreamWriter(OutputStream
      out):依据私下认可编码把字节流的数目转变为字符流
    • OutputStreamWriter(OutputStream out,String
      charsetName):依照内定编码把字节流多少调换为字符流
  • InputStream里德r 字符输入流

    • InputStreamReader(InputStream is):用暗中认可的编码读取数据
    • InputStreamReader(InputStream is,String
      charsetName):用钦命的编码读取数据

0九字节输入流缓冲流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();
            }
        }

十多样文件复制格局的频率相比较

* 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();
            }
        }

OutputStreamWriter写数据

  • OutputStreamWriter写多少格局
    • public void write(int c):写一个字符
    • public void write(char[] cbuf):写二个字符数组
    • public void write(char[] cbuf,int off,int
      len):写3个字符数组的一局地
    • public void write(String str):写三个字符串
    • public void write(String str,int off,int
      len):写2个字符串的壹有的

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        // "osw.txt")); // 默认GBK
        // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        // "osw.txt"), "GBK"); // 指定GBK
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw.txt"), "UTF-8"); // 指定UTF-8
        // 写数据
        osw.write("中国");

        // 释放资源
        osw.close();
    }
}

拾各个文件复制格局的作用相比

* 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();
            }
        }

1壹字符输出流缓冲流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();

            }
        }

字符流操作要专注的标题

  • flush()和close()的区别
    • A:close()关闭流对象,可是先刷新1回缓冲区。关闭之后,流对象不可以一而再再使用了。
    • B:flush()仅仅刷新缓冲区,刷新之后,流对象还是能够一而再行使。

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw2.txt"));

        // 写数据
        // public void write(int c):写一个字符
        // osw.write('a');
        // osw.write(97);
        // 为什么数据没有进去呢?
        // 原因是:字符 = 2字节
        // 文件中数据存储的基本单位是字节。
        // void flush()

        // public void write(char[] cbuf):写一个字符数组
        // char[] chs = {'a','b','c','d','e'};
        // osw.write(chs);

        // public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
        // osw.write(chs,1,3);

        // public void write(String str):写一个字符串
        // osw.write("我爱林青霞");

        // public void write(String str,int off,int len):写一个字符串的一部分
        osw.write("我爱林青霞", 2, 3);

        // 刷新缓冲区
        osw.flush();
        // osw.write("我爱林青霞", 2, 3);

        // 释放资源
        osw.close();
        // java.io.IOException: Stream closed
        // osw.write("我爱林青霞", 2, 3);
    }
}

1一字符输出流缓冲流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();

            }
        }

1贰字符输出流缓冲流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();

            }
        }

InputStreamReader读数据

  • 读数据方法
    • int read():1回读取2个字符
    • int read(char[] chs):2次读取二个字符数组

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        // InputStreamReader isr = new InputStreamReader(new FileInputStream(
        // "osw.txt"));

        // InputStreamReader isr = new InputStreamReader(new FileInputStream(
        // "osw.txt"), "GBK");

        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "osw.txt"), "UTF-8");

        // 读取数据
        // 一次读取一个字符
        int ch = 0;
        while ((ch = isr.read()) != -1) {
            System.out.print((char) ch);
        }

        // 释放资源
        isr.close();
    }
}



public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "StringDemo.java"));

        // 一次读取一个字符
        // int ch = 0;
        // while ((ch = isr.read()) != -1) {
        // System.out.print((char) ch);
        // }

        // 一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        // 释放资源
        isr.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();

            }
        }

1叁字符输入流缓冲流BufferedReader

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

字符流复制文本文件

  • 把当下项目目录下的a.txt内容复制到当前项目目录下的b.txt中

/*
 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源:
 *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
 * 目的地:
 *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "a.txt"));
        // 封装目的地
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "b.txt"));

        // 读写数据
        // 方式1
        // int ch = 0;
        // while ((ch = isr.read()) != -1) {
        // osw.write(ch);
        // }

        // 方式2
        char[] chs = new char[1024];
        int len = 0;
        while ((len = isr.read(chs)) != -1) {
            osw.write(chs, 0, len);
            // osw.flush();
        }

        // 释放资源
        osw.close();
        isr.close();
    }
}
  • 把c:\a.txt内容复制到d:\b.txt中

一三字符输入流缓冲流Buffered里德r

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

1四字符输入流缓冲流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);
         */

转变流的简化写法

  • 调换流的名字比较长,而大家广阔的操作都以依照本地默许编码实现的,所以,为了简化大家的书写,转变流提供了相应的子类。

  • FileWriter写数据

  • FileReader读取数据

  • OutputStreamWriter = FileOutputStream + 编码表(GBK)

    • FileWriter = FileOutputStream + 编码表(GBK)
  • InputStreamReader = FileInputStream + 编码表(GBK)

    • FileReader = FileInputStream + 编码表(GBK)

/*
 * 由于我们常见的操作都是使用本地默认编码,所以,不用指定编码。
 * 而转换流的名称有点长,所以,Java就提供了其子类供我们使用。
 * OutputStreamWriter = FileOutputStream + 编码表(GBK)

 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源:
 *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
 * 目的地:
 *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileReader fr = new FileReader("a.txt");
        // 封装目的地
        FileWriter fw = new FileWriter("b.txt");

        // 一次一个字符
        // int ch = 0;
        // while ((ch = fr.read()) != -1) {
        // fw.write(ch);
        // }

        // 一次一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
            fw.flush();
        }

        // 释放资源
        fw.close();
        fr.close();
    }
}

1四字符输入流缓冲流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);
         */

壹5字符流缓冲区流复制文本文件

* 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();
            }
        }

字符缓冲流

  • 字符流为了神速读写,也提供了对应的字符缓冲流。
    • BufferedWriter:字符缓冲输出流
    • BufferedReader:字符缓冲输入流

一五字符流缓冲区流复制文本文件

* 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
            * 已经明确到了具体的体系上。
BufferedWriter:字符缓冲输出流
  • 将文件写入字符输出流,缓冲各样字符,从而提供单个字符、数组和字符串的快捷写入。
  • 能够钦点缓冲区的轻重缓急,或许接受默认的大大小小。在大部情状下,暗中同意值就够用大了。

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        // BufferedWriter(Writer out)
        // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
        // new FileOutputStream("bw.txt")));

        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

        bw.write("hello");
        bw.write("world");
        bw.write("java");
        bw.flush();

        bw.close();
    }
}

1六IO流目的的操作原理

* 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
            * 已经明确到了具体的体系上。
            * 
BufferedReader
  • 从字符输入流中读取文本,缓冲各类字符,从而完毕字符、数组和行的不慢读取。
  • 能够钦命缓冲区的深浅,或然可使用暗中认可的轻重。大多数状态下,默许值就够用大了。

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

        // 方式1
        // int ch = 0;
        // while ((ch = br.read()) != -1) {
        // System.out.print((char) ch);
        // }

        // 方式2
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        // 释放资源
        br.close();
    }
}
  • 文件复制例子

/*
 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源:
 *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地:
 *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        // 两种方式其中的一种一次读写一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
            bw.flush();
        }

        // 释放资源
        bw.close();
        br.close();
    }
}

作业测试

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

  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文件中(要求用高效流)

三.运用转换流将GBK格式文件以UTF-八输出

四.java写二个先后,达成从文件中读出文件内容,并将其打字与印刷在显示器中间,并标明上行号

设若想进一步的沟通,能够投入大家的QQ群,里面有流行的就学材质,可以学习。

图片 2

字符缓冲流的独具匠心措施

  • BufferedWriter:
    • public void newLine():根据系统来决定换行符
  • BufferedReader:
    • public String readLine():一回读取1行数据
      • 含蓄该行内容的字符串,不带有其余行终止符,要是已达到流末尾,则赶回null

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));

        // 最终版代码
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        br.close();
    }

    private static void write() throws IOException {
        // 创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        for (int x = 0; x < 10; x++) {
            bw.write("hello" + x);
            // bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }

}
  • 字符缓冲流特殊效果复制文本文件)(必会)

/*
 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源:
 *         a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地:
 *         b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        // 读写数据
        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        // 释放资源
        bw.close();
        br.close();
    }
}

IO流小结

  • 字节流
    • 字节输入流
    • 字节输出流
  • 字符流
    • 字符输入流
    • 字符输出流

图片 3

IO流练习

  • 复制文本文件

/*
 * 复制文本文件
 * 
 * 分析:
 *         而字符流有5种方式,所以做这个题目我们有5种方式。推荐掌握第5种。
 * 数据源:
 *         c:\\a.txt -- FileReader -- BufferdReader
 * 目的地:
 *         d:\\b.txt -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        String srcString = "c:\\a.txt";
        String destString = "d:\\b.txt";
        // method1(srcString, destString);
        // method2(srcString, destString);
        // method3(srcString, destString);
        // method4(srcString, destString);
        method5(srcString, destString);
    }

    // 字符缓冲流一次读写一个字符串
    private static void method5(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        bw.close();
        br.close();
    }

    // 字符缓冲流一次读写一个字符数组
    private static void method4(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
        }

        bw.close();
        br.close();
    }

    // 字符缓冲流一次读写一个字符
    private static void method3(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

        int ch = 0;
        while ((ch = br.read()) != -1) {
            bw.write(ch);
        }

        bw.close();
        br.close();
    }

    // 基本字符流一次读写一个字符数组
    private static void method2(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);

        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
        }

        fw.close();
        fr.close();
    }

    // 基本字符流一次读写一个字符
    private static void method1(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);

        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }

        fw.close();
        fr.close();
    }
}
  • 复制图片

/*
 * 复制图片
 * 
 * 分析:
 *         复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
 *         通过该原理,我们知道我们应该采用字节流。
 *         而字节流有4种方式,所以做这个题目我们有4种方式。推荐掌握第4种。
 * 
 * 数据源:
 *         c:\\a.jpg -- FileInputStream -- BufferedInputStream
 * 目的地:
 *         d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
 */
public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
        // 使用字符串作为路径
        // String srcString = "c:\\a.jpg";
        // String destString = "d:\\b.jpg";
        // 使用File对象做为参数
        File srcFile = new File("c:\\a.jpg");
        File destFile = new File("d:\\b.jpg");

        // method1(srcFile, destFile);
        // method2(srcFile, destFile);
        // method3(srcFile, destFile);
        method4(srcFile, destFile);
    }

    // 字节缓冲流一次读写一个字节数组
    private static void method4(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

    // 字节缓冲流一次读写一个字节
    private static void method3(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));

        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }

        bos.close();
        bis.close();
    }

    // 基本字节流一次读写一个字节数组
    private static void method2(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

        fos.close();
        fis.close();
    }

    // 基本字节流一次读写一个字节
    private static void method1(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        fos.close();
        fis.close();
    }
}
  • 把ArrayList集合中的字符串数据存款和储蓄到文本文件

/*
 * 需求:把ArrayList集合中的字符串数据存储到文本文件
 * 
 * 分析:
 * 通过题目的意思我们可以知道如下的一些内容,
 * ArrayList集合里存储的是字符串。
 * 遍历ArrayList集合,把数据获取到。
 * 然后存储到文本文件中。
 * 文本文件说明使用字符流。
 * 
 * 数据源:
 *         ArrayList<String> -- 遍历得到每一个字符串数据
 * 目的地:
 *         a.txt -- FileWriter -- BufferedWriter
 */
public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源(创建集合对象)
        ArrayList<String> array = new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("java");

        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        // 遍历集合
        for (String s : array) {
            // 写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

        // 释放资源
        bw.close();
    }
}
  • 从文本文件中读取数据(每一行事一个字符串数据)到集合中,并遍历集合

/*
 * 需求:从文本文件中读取数据(每一行为一个字符串数据)到集合中,并遍历集合
 * 
 * 分析:
 *         通过题目的意思我们可以知道如下的一些内容,
 *             数据源是一个文本文件。
 *             目的地是一个集合。
 *             而且元素是字符串。
 * 
 * 数据源:
 *         b.txt -- FileReader -- BufferedReader
 * 目的地:
 *         ArrayList<String>
 */
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        // 封装目的地(创建集合对象)
        ArrayList<String> array = new ArrayList<String>();

        // 读取数据存储到集合中
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }

        // 释放资源
        br.close();

        // 遍历集合
        for (String s : array) {
            System.out.println(s);
        }
    }
}
  • 率性获得文本中的名字

/*
 * 需求:我有一个文本文件中存储了几个名称,请大家写一个程序实现随机获取一个人的名字。
 * 
 * 分析:
 *         A:把文本文件中的数据存储到集合中
 *         B:随机产生一个索引
 *         C:根据该索引获取一个值
 */
public class GetName {
    public static void main(String[] args) throws IOException {
        // 把文本文件中的数据存储到集合中
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        ArrayList<String> array = new ArrayList<String>();
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }
        br.close();

        // 随机产生一个索引
        Random r = new Random();
        int index = r.nextInt(array.size());

        // 根据该索引获取一个值
        String name = array.get(index);
        System.out.println("该幸运者是:" + name);
    }
}
  • 复制单极文件夹

/*
 * 需求:复制单极文件夹
 * 
 * 数据源:e:\\demo
 * 目的地:e:\\test
 * 
 * 分析:
 *         A:封装目录
 *         B:获取该目录下的所有文本的File数组
 *         C:遍历该File数组,得到每一个File对象
 *         D:把该File进行复制
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封装目录
        File srcFolder = new File("e:\\demo");
        // 封装目的地
        File destFolder = new File("e:\\test");
        // 如果目的地文件夹不存在,就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取该目录下的所有文本的File数组
        File[] fileArray = srcFolder.listFiles();

        // 遍历该File数组,得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // 数据源:e:\\demo\\e.mp3
            // 目的地:e:\\test\\e.mp3
            String name = file.getName(); // e.mp3
            File newFile = new File(destFolder, name); // e:\\test\\e.mp3

            copyFile(file, newFile);
        }
    }

    private static void copyFile(File file, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                file));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}
  • 复制单极文件夹中钦定文件并修改文件名称

/*
 * 需求:复制指定目录下的指定文件,并修改后缀名。
 * 指定的文件是:.java文件。
 * 指定的后缀名是:.jad
 * 指定的目录是:jad
 * 
 * 数据源:e:\\java\\A.java
 * 目的地:e:\\jad\\A.jad
 * 
 * 分析:
 *         A:封装目录
 *         B:获取该目录下的java文件的File数组
 *         C:遍历该File数组,得到每一个File对象
 *         D:把该File进行复制
 *         E:在目的地目录下改名
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封装目录
        File srcFolder = new File("e:\\java");
        // 封装目的地
        File destFolder = new File("e:\\jad");
        // 如果目的地目录不存在,就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取该目录下的java文件的File数组
        File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".java");
            }
        });

        // 遍历该File数组,得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // 数据源:e:\java\DataTypeDemo.java
            // 目的地:e:\\jad\DataTypeDemo.java
            String name = file.getName();
            File newFile = new File(destFolder, name);
            copyFile(file, newFile);
        }

        // 在目的地目录下改名
        File[] destFileArray = destFolder.listFiles();
        for (File destFile : destFileArray) {
            // System.out.println(destFile);
            // e:\jad\DataTypeDemo.java
            // e:\\jad\\DataTypeDemo.jad
            String name =destFile.getName(); //DataTypeDemo.java
            String newName = name.replace(".java", ".jad");//DataTypeDemo.jad

            File newFile = new File(destFolder,newName);
            destFile.renameTo(newFile);
        }
    }

    private static void copyFile(File file, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                file));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}
  • 复制多极文件夹

/*
 * 需求:复制多极文件夹
 * 
 * 数据源:E:\JavaSE\day21\code\demos
 * 目的地:E:\\
 * 
 * 分析:
 *         A:封装数据源File
 *         B:封装目的地File
 *         C:判断该File是文件夹还是文件
 *             a:是文件夹
 *                 就在目的地目录下创建该文件夹
 *                 获取该File对象下的所有文件或者文件夹File对象
 *                 遍历得到每一个File对象
 *                 回到C
 *             b:是文件
 *                 就复制(字节流)
 */
public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源File
        File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
        // 封装目的地File
        File destFile = new File("E:\\");

        // 复制文件夹的功能
        copyFolder(srcFile, destFile);
    }

    private static void copyFolder(File srcFile, File destFile)
            throws IOException {
        // 判断该File是文件夹还是文件
        if (srcFile.isDirectory()) {
            // 文件夹
            File newFolder = new File(destFile, srcFile.getName());
            newFolder.mkdir();

            // 获取该File对象下的所有文件或者文件夹File对象
            File[] fileArray = srcFile.listFiles();
            for (File file : fileArray) {
                copyFolder(file, newFolder);
            }
        } else {
            // 文件
            File newFile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newFile);
        }
    }

    private static void copyFile(File srcFile, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}
  • 键盘录入三个学生音讯(姓名,语文成绩,数学成就,葡萄牙语成绩),根据总分从高到低存入文本文件

/*
 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
 * 
 * 分析:
 *         A:创建学生类
 *         B:创建集合对象
 *             TreeSet<Student>
 *         C:键盘录入学生信息存储到集合
 *         D:遍历集合,把数据写到文本文件
 */
public class StudentDemo {
    public static void main(String[] args) throws IOException {
        // 创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
                int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
                        : num4;
                return num5;
            }
        });

        // 键盘录入学生信息存储到集合
        for (int x = 1; x <= 5; x++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + x + "个的学习信息");
            System.out.println("姓名:");
            String name = sc.nextLine();
            System.out.println("语文成绩:");
            int chinese = sc.nextInt();
            System.out.println("数学成绩:");
            int math = sc.nextInt();
            System.out.println("英语成绩:");
            int english = sc.nextInt();

            // 创建学生对象
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            // 把学生信息添加到集合
            ts.add(s);
        }

        // 遍历集合,把数据写到文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
        bw.write("学生信息如下:");
        bw.newLine();
        bw.flush();
        bw.write("姓名,语文成绩,数学成绩,英语成绩");
        bw.newLine();
        bw.flush();
        for (Student s : ts) {
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese())
                    .append(",").append(s.getMath()).append(",")
                    .append(s.getEnglish());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 释放资源
        bw.close();
        System.out.println("学习信息存储完毕");
    }
}
  • 已知s.txt文件中有如此的四个字符串:“hcexfgijkamdnoqrzstuvwybpl”
    • 请编写程序读取数据内容,把数量排序后写入ss.txt中。

/*
 * 已知s.txt文件中有这样的一个字符串:“hcexfgijkamdnoqrzstuvwybpl”
 * 请编写程序读取数据内容,把数据排序后写入ss.txt中。
 * 
 * 分析:
 *         A:把s.txt这个文件给做出来
 *         B:读取该文件的内容,存储到一个字符串中
 *         C:把字符串转换为字符数组
 *         D:对字符数组进行排序
 *         E:把排序后的字符数组转换为字符串
 *         F:把字符串再次写入ss.txt中
 */
public class StringDemo {
    public static void main(String[] args) throws IOException {
        // 读取该文件的内容,存储到一个字符串中
        BufferedReader br = new BufferedReader(new FileReader("s.txt"));
        String line = br.readLine();
        br.close();

        // 把字符串转换为字符数组
        char[] chs = line.toCharArray();

        // 对字符数组进行排序
        Arrays.sort(chs);

        // 把排序后的字符数组转换为字符串
        String s = new String(chs);

        // 把字符串再次写入ss.txt中
        BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
        bw.write(s);
        bw.newLine();
        bw.flush();

        bw.close();
    }
}
  • 用Reader模拟BufferedReader的readLine()功能

/*
 * 用Reader模拟BufferedReader的readLine()功能
 * 
 * readLine():一次读取一行,根据换行符判断是否结束,只返回内容,不返回换行符
 */
public class MyBufferedReader {
    private Reader r;

    public MyBufferedReader(Reader r) {
        this.r = r;
    }

    /*
     * 思考:写一个方法,返回值是一个字符串。
     */
    public String readLine() throws IOException {
        /*
         * 我要返回一个字符串,我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法,一次读取一个字符或者一次读取一个字符数组
         * 那么,我们要返回一个字符串,用哪个方法比较好呢? 我们很容易想到字符数组比较好,但是问题来了,就是这个数组的长度是多长呢?
         * 根本就没有办法定义数组的长度,你定义多长都不合适。 所以,只能选择一次读取一个字符。
         * 但是呢,这种方式的时候,我们再读取下一个字符的时候,上一个字符就丢失了 所以,我们又应该定义一个临时存储空间把读取过的字符给存储起来。
         * 这个用谁比较合适呢?数组,集合,字符串缓冲区三个可供选择。
         * 经过简单的分析,最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
         */
        StringBuilder sb = new StringBuilder();

        // 做这个读取最麻烦的是判断结束,但是在结束之前应该是一直读取,直到-1


        /*
        hello
        world
        java    

        104101108108111
        119111114108100
        1069711897
         */

        int ch = 0;
        while ((ch = r.read()) != -1) { //104,101,108,108,111
            if (ch == '\r') {
                continue;
            }

            if (ch == '\n') {
                return sb.toString(); //hello
            } else {
                sb.append((char)ch); //hello
            }
        }

        // 为了防止数据丢失,判断sb的长度不能大于0
        if (sb.length() > 0) {
            return sb.toString();
        }

        return null;
    }

    /*
     * 先写一个关闭方法
     */
    public void close() throws IOException {
        this.r.close();
    }
}
  • 自定义类模拟LineNumberReader的特有成效
    • 得到每趟读取数据的行号

public class MyLineNumberReaderTest {
    public static void main(String[] args) throws IOException {
        // MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader(
        // "my.txt"));

        MyLineNumberReader2 mlnr = new MyLineNumberReader2(new FileReader(
                "my.txt"));

        // mlnr.setLineNumber(10);

        // System.out.println(mlnr.getLineNumber());
        // System.out.println(mlnr.getLineNumber());
        // System.out.println(mlnr.getLineNumber());

        String line = null;
        while ((line = mlnr.readLine()) != null) {
            System.out.println(mlnr.getLineNumber() + ":" + line);
        }

        mlnr.close();
    }
}





public class MyLineNumberReader2 extends MyBufferedReader {
    private Reader r;

    private int lineNumber = 0;

    public MyLineNumberReader2(Reader r) {
        super(r);
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    @Override
    public String readLine() throws IOException {
        lineNumber++;
        return super.readLine();
    }
}

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website