Java基础语法（二十四）

版权声明：作者已开启版权声明，如转载请注明转载地址。 https://blog.csdn.net/qq_34829447/article/details/82156527

一.转换流

1.转换流概述

• OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的字符编码表，将要写入流中的字符编码成字节，在使用字节流将这些字节写出去

2.OutputStreamWriter写文本文件

• OutputStreamWriter

  • java.io.OutputStreamWriter 继承Writer类
  • 就是一个字符输出流，写文本文件
  • write()字符，字符数组，字符串
  • 字符通向字节的桥梁，将字符流转字节流

• OutputStreamWriter构造方法

  • OutputStreamWriter(OuputStream out)接收所有的字节输出流
  • OutputStreamWriter(OutputStream out, String charsetName)String charsetName 传递编码表名字 GBK UTF-8
  • OutputStreamWriter 有个子类，FileWriter

• 实例代码

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

3.转换流——字节转字符过程

• InputStreamReader

  • java.io.InputStreamReader 继承 Reader
  • 读取的方法:read() 读取1个字符，读取字符数组
  • 技巧
    
    • OuputStreamWriter写了文件
    • InputStreamReader读取文件
  • OutputStreamWriter(OutputStream out)所有字节输出流
  • InputStreamReader(InputStream in) 接收所有的字节输入流
  • InputStreamReader(InputStream in,String charsetName) 传递编码表的名字

• 图解

  

• InputStreamReader读取文本文件

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

4.转换流子类父类的区别

• 转换流子类父类的继承关系

  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.缓冲流概述

• 可提高IO流的读写速度
• 分为字节缓冲流与字符缓冲流

2.字节输出流缓冲流BufferedOutputStream

• BufferedOutputStream字节输出流的缓冲流

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

• 实例代码

  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"));
        byte[] bytes = "HelloWorld".getBytes();
        bos.write(bytes);
        bos.write(bytes, 3, 2);//lo
        bos.close();
    }
  }

3.字节输入流缓冲流BufferedInputStream

• 字节输入流缓冲流BufferedInputStream

  • 继承InputStream,标准的字节输入流
  • 读取方法 read() 单个字节,字节数组
  • 构造方法:BufferedInputStream(InputStream in)可以传递任意的字节输入流,传递是谁,就提高谁的效率，可以传递的字节输入流 FileInputStream

• 实例代码

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

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

• 四种复制方式

  • 字节流读写单个字节125250 毫秒
  • 字节流读写字节数组193毫秒 OK
  • 字节流缓冲区流读写单个字节1210毫秒
  • 字节流缓冲区流读写字节数组73毫秒 OK

• 实例代码

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

5.字符输出流缓冲流BufferedWriter

• BufferedWriter字符输出流缓冲区流

  • java.io.BufferedWriter 继承 Writer
  • 写入方法 write () 单个字符,字符数组,字符串
  • 构造方法：BufferedWriter(Writer w)传递任意字符输出流,传递谁,就高效谁
  • 能传递的字符输出流 FileWriter, OutputStreamWriter

• 实例代码

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

• 字符输出流缓冲流BufferedWriter**特有方法newLine()写换行**

  /*
  * newLine()文本中换行, \r\n也是文本换行
  * 方法具有平台无关性
  * Windows  \r\n
  * Linux    \n     
  * newLine()运行结果,和操作系统是相互关系
  * JVM: 安装的是Windows版本,newLine()写的就是\r\n
  * 安装的是Linux版本,newLine()写的就是\n
  */
  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();
  
    }
  }

6.字符输入流缓冲流BufferedReader

• 字符输入流缓冲流BufferedReader

  • java.io.BufferedReader 继承 Reader,从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
  • 读取功能 read() 单个字符,字符数组
  • 构造方法:BufferedReader(Reader r)可以任意的字符输入流FileReader InputStreamReader
  • BufferedReader自己的功能public String readLine()读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

• 小特点

  • 获取内容的方法一般都有返回值
  • int 没有返回的都是负数
  • 引用类型 找不到返回null
  • boolean 找不到返回false

• 实例代码

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

7.字符流缓冲流复制文本

/*
             *  使用缓冲区流对象,复制文本文件
             *  数据源  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();
    }
}

三.IO流对象的操作规律

1.明确：要操作的数据是数据源还是数据目的

• 源：InputStream Reader
• 目的：OutputStream Writer
• 先根据需求明确要读，还是要写

2.明确：要操作的数据是字节还是文本

• 源
  
  • 字节：InputStream
  • 文本：Reader
• 目的
  
  • 字节：OutputStream
  • 文本：Writer

3.明确：明确数据所在的具体设备

• 源设备
  
  • 硬盘：文件 File开头。
  • 内存：数组，字符串。
  • 键盘：System.in
  • 网络：Socket
• 目的设备
  
  • 硬盘：文件 File开头
  • 内存：数组，字符串
  • 屏幕：System.out
  • 网络：Socket

4.明确：是否需要额外功能

• 转换吗？转换流。InputStreamReader OutputStreamWriter
• 高效吗？缓冲区对象。BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter