IO流及转换流

IO流
IO流：用来处理设备之间的数据传输

分类：

1. 按照数据流向，站在内存角度

   输入流：读入数据
   输出流：写出数据
   

2. 按照数据类型

   字节流：可以读写任何类型的文件，比如音频、视频、文本文件
   字符流：只能读写文本文件
   

IO流基类概述

• 字节流的抽象基类：

   InputStream ，OutputStream。
  

• 字符流的抽象基类：

   Reader ， Writer。
  

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

• 字节流

   字节输入流	InputStream	    读
   字节输出流	OutputStream 	写
  

• 字符流

   字符输入流  Reader		读
   字符输出流	Writer		写
  

FileOutputStream
类FileOutputStream文件输出流是用于将数据写入 File 的输出流

1. void close() ：关闭输出流资源
2. void write(byte[] b) ：写入一个数组
3. void write(byte[] b, int off, int len)：写入一个数组的指定部分，off是起始位置，len是写入数组的长度
4. void write(int b) ：写入一个字节

FileInputStream
FileInputStream 文件输入流，读取文件的字节数据

1. void close() ：关闭输入流资源
2. int read() ：读取一个字节
3. int read(byte[] b) ：读取一个数组
4. int read(byte[] b, int off, int
   len)：读取一个数组的指定部分，off是起始位置，len是写入数组的长度

package demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
//复制文本文件
public class Test5 {
    public static void main(String[] args) throws IOException {
        FileInputStream f1 = new FileInputStream("F:/JavaTxt/a.txt");
        FileOutputStream f2=new FileOutputStream("F:/JavaTxt/c.txt");
        long t1=System.currentTimeMillis();
        while (true){
            int b=f1.read();
            if (b == -1) {
                break;
            }
            f2.write(b);
        }
        f1.close();
        f2.close();
long t2=System.currentTimeMillis();
        System.out.println("复制耗时"+(t2 - t1)+"毫秒");
    }
}
运行结果：
复制耗时8毫秒

OutputStreamWriter
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。

1. void close() ：关闭输出流
2. void flush() ：刷新该流的缓冲
3. void write(int c)： 写入一个字符
4. void write(String str, int off, int len) ：写入字符串的一部分

InputStreamReader
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

1. void close() ：关闭输入流

2. int read() ：读取一个字符

3. int read(char[] cbuf, int offset, int length) ：读取字符串数组的一部分

package demo2;
import java.io.*;
//一次读写一个字符，来复制文本文件
public class Test5 {
    public static void main(String[] args) throws IOException {
       InputStreamReader reader=new InputStreamReader(new FileInputStream("F:/JavaTxt/a.txt"));
       OutputStreamWriter writer=new OutputStreamWriter(new FileOutputStream("F:/JavaTxt/aa.txt"));
       long t1=System.currentTimeMillis();
       int i = 0;
       while (i!=-1){
           i=reader.read();
           writer.flush();
           writer.write(i);
       }
        long t2=System.currentTimeMillis();
        System.out.println("一次读写一个字符，来复制文本文件总耗时："+(t2 - t1)+"毫秒");//5毫秒
       reader.close();
       writer.close();
    }
}
运行结果：
一次读写一个字符，来复制文本文件总耗时：5毫秒

FileReader
FileReader是InputStreamReader的便捷类

1. void close() ：关闭输入流
2. int read() ：读取一个字符
3. int read(char[] cbuf, int offset, int length) ：读取字符串数组的一部分

FileWriter
FileWriter是OutputStreamWriter的便捷类

1. void close() ：关闭输出流
2. void flush() ：刷新该流的缓冲
3. void write(int c)： 写入一个字符
4. void write(String str, int off, int len) ：写入字符串的一部分

package demo2;
import java.io.*;
//字符流便捷类：FileReader方法复制
public class Test7 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("F:/JavaTxt/a.txt");
        FileWriter fw = new FileWriter("F:/JavaTxt/a4.txt");
        long t1=System.currentTimeMillis();
        char[]arr = new char[100];
        int len=0;
        while ((len=fr.read(arr))!=-1){
//            len=fr.read(arr);
//            fw.flush();
            fw.write(arr, 0, len);
        }
        long t2=System.currentTimeMillis();
        System.out.println("一次读写多个字符，来复制文本文件总耗时："+(t2 - t1)+"毫秒");//1毫秒
        fr.close();
        fw.close();

    }
}
运行结果：
一次读写多个字符，来复制文本文件总耗时：0毫秒

BufferedReader
类 BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

1. void close() ：关闭输入流
2. int read() ：读取一个字符
3. String readLine() ：读一行
4. int read(char[] cbuf, int off, int len)：读取一个字符数组的一部分

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

1. void close() ：关闭输出流
2. void flush() ：刷新缓冲区
3. void newLine() ：写入一个行分隔符
4. void write(char[] cbuf, int off, int len)：写一个字符数组的指定部分
5. void write(int c) ：写入一个字符
6. void write(String s, int off, int len)：写入一个字符串的指定部分

package demo2;
import java.io.*;
//BufferedWriter
// BufferedWriter
public class Test8 {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("F:/JavaTxt/a.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("F:/JavaTxt/a5.txt"));
        long t1=System.currentTimeMillis();
        char[]arr=new char[100];
        int len=0;//定义读取到的长度
        while ((len=br.read(arr)) != -1){
            bw.write(arr,0,len);
        }
        long t2=System.currentTimeMillis();
        System.out.println("一次读写多个字符，来复制文本文件总耗时："+(t2 - t1)+"毫秒");//0毫秒
        br.close();
        bw.close();
    }
}
运行结果：
一次读写多个字符，来复制文本文件总耗时：0毫秒

总结一下：

字节流

• 继承体系

   InputStream     FileInputStream
   OutputStream    FileOutputStream
  

高效流

1. 字符高效流

   BufferedReader
   BufferedWriter
   

2. 字节高效流

   BufferedInputStream
   BufferedOutputStream
   

3. 字符高效流的特殊功能

   BufferedReader  String readLine()
   BufferedWriter  void newLine()