Java基础程序——转换流和缓冲流

目录

一、转换流

1.1、OutputStreamWriter

1.2、InputStreamReader

1.3、转换流和子类的区别

二、字节缓冲流

2.1、字节缓冲输出流BufferedOutputStream

2.2、字节缓冲输入流BufferedInputStream

2.3、使用基本流和高效流完成复制文件

三、字符缓冲流

3.1、字符缓冲流

3.2、字符缓冲输出流：BufferedWriter

3.3、字符缓冲输入流：BufferedReader

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

四、流的操作规律

---

一、转换流

1.1、OutputStreamWriter

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

public static void writeCN() throws Exception {
//创建与文件关联的字节输出流对象
FileOutputStream fos = new FileOutputStream("e:\\cn8.txt");
//创建可以把字符转成字节的转换流对象，并指定编码
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
//调用转换流，把文字写出去，其实是写到转换流的缓冲区中
osw.write("你好");//写入缓冲区。
osw.close();
}

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

1.2、InputStreamReader

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

 

public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
//演示字节转字符流的转换流
readCN();
}
public static void readCN() throws IOException{
//创建读取文件的字节流对象
InputStream in = new FileInputStream("e:\\cn8.txt");
//创建转换流对象
//InputStreamReader isr = new InputStreamReader(in);这样
创建对象，会用本地默认码表读取，将会发生错误解码的错误
InputStreamReader isr = new InputStreamReader(in,"utf8");
//使用转换流去读字节流中的字节
int ch = 0;
while((ch = isr.read())!=-1){
System.out.println((char)ch);
}
//关闭流
isr.close();
}
}

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

1.3、转换流和子类的区别

继承关系：

OutputStreamWriter

           |- FileWirter

InputStreamReader

           |- FileReader

父类与子类的功能有什么区别呢？

• OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转 换流。字符转换流原理：字节流+编码表。
• FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字 符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。

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

• 这三句代码的功能是一样的，其中第三句最为便捷。 注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。

什么时候用子类呢？

• 条件：

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

• 总结：

1. 字节--->字符 ： 看不懂的--->看的懂的。 需要读。输入流。 InputStreamReader
2. 字符--->字节 ： 看的懂的--->看不懂的。 需要写。输出流。 OutputStreamWriter

---

二、字节缓冲流

• 字节缓冲流根据流的方向，共有2个
• 写入数据到流中，字节缓冲输出流 BufferedOutputStream
• 读取流中的数据，字节缓冲输入流 BufferedInputStream
• 它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

2.1、字节缓冲输出流BufferedOutputStream

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

• 构造方法

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

• 代码示例：

public class BufferedOutputStreamDemo01 {
public static void main(String[] args) throws
IOException {
//写数据到文件的方法
write();
}
/*
* 写数据到文件的方法
* 1,创建流
* 2，写数据
* 3，关闭流
*/
private static void write() throws IOException {
//创建基本的字节输出流
FileOutputStream fileOut = new
FileOutputStream("abc.txt");
//使用高效的流，把基本的流进行封装，实现速度的提升
BufferedOutputStream out = new
BufferedOutputStream(fileOut);
//2，写数据
out.write("hello".getBytes());
//3，关闭流
out.close();
}
}

2.2、字节缓冲输入流BufferedInputStream

读取文件中数据

• 构造方法

public BufferedInputStream(InputStream in)

• 代码示例

/*
* 从文件中读取数据
* 1,创建缓冲流对象
* 2，读数据，打印
* 3，关闭
*/
private static void read() throws IOException {
//1,创建缓冲流对象
FileInputStream fileIn = new
FileInputStream("abc.txt");
//把基本的流包装成高效的流
BufferedInputStream in = new
BufferedInputStream(fileIn);
//2，读数据
int ch = -1;
while ( (ch = in.read()) != -1 ) {
//打印
System.out.print((char)ch);
}
//3，关闭
in.close();
}

2.3、使用基本流和高效流完成复制文件

通过一个复制文件耗时的比较过程，来比较高效流与普通流。

/*
* 需求：将d:\\test.mp4文件进行复制
* 采用4种方式复制
* 方式1： 采用基本的流，一次一个字节的方式复制 共耗时 224613毫秒
* 方式2： 采用基本的流，一个多个字节的方式赋值 共耗时 327毫秒
* 方式3： 采用高效的流，一次一个字节的方式复制 共耗时 2047毫秒
* 方式4： 采用高效的流，一个多个字节的方式赋值 共耗时 96毫秒
*
* 数据源： d:\\test.mp4
* 目的地1: d:\\copy1.mp4
* 目的地2: d:\\copy2.mp4
* 目的地3: d:\\copy3.mp4
* 目的地4: d:\\copy4.mp4
*
* 实现的步骤：
* 1，指定数据源
* 2，指定目的地
* 3，读数据
* 4，写数据
* 5，关闭流
*
*/
public class CopyVideo {
public static void main(String[] args) throws IOException {
//开始计时
long start = System.currentTimeMillis();
//方式1： 采用基本的流，一次一个字节的方式复制
//method1("d:\\test.mp4", "d:\\copy1.mp4");
//方式2： 采用基本的流，一个多个字节的方式赋值
//method2("d:\\test.mp4", "d:\\copy2.mp4");
//方式3： 采用高效的流，一次一个字节的方式复制
//method3("d:\\test.mp4", "d:\\copy3.mp4");
//方式4： 采用高效的流，一个多个字节的方式赋值
method4("d:\\test.mp4", "d:\\copy4.mp4");
//结束计时
long end = System.currentTimeMillis();
//打印耗时多少毫秒
System.out.println("共耗时 " +(end - start)+ "毫秒");
}
//方式4： 采用高效的流，一个多个字节的方式赋值
private static void method4(String src, String dest) throws
IOException {
//1，指定数据源
BufferedInputStream in = new BufferedInputStream(new
FileInputStream(src));
//2，指定目的地
BufferedOutputStream out = new BufferedOutputStream(new
FileOutputStream(dest));
//3，读数据
byte[] buffer = new byte[1024];
int len = -1;
while ( (len = in.read(buffer)) != -1) {
//4,写数据
out.write(buffer, 0, len);
}
//5，关闭流
in.close();
out.close();
}
//方式3： 采用高效的流，一次一个字节的方式复制
private static void method3(String src, String dest) throws
IOException {
//1，指定数据源
BufferedInputStream in = new BufferedInputStream(new
FileInputStream(src));
//2，指定目的地
BufferedOutputStream out = new BufferedOutputStream(new
FileOutputStream(dest));
//3，读数据
int ch = -1;
while ((ch=in.read()) != -1) {
//4，写数据
out.write(ch);
}
//5，关闭流
in.close();
out.close();
}
//方式2： 采用基本的流，一个多个字节的方式赋值
private static void method2(String src, String dest) throws
IOException {
//1，指定数据源
FileInputStream in = new FileInputStream(src);
//2，指定目的地
FileOutputStream out = new FileOutputStream(dest);
//3，读数据
byte[] buffer = new byte[1024];
int len = -1;
while ( (len=in.read(buffer)) != -1) {
//4，写数据
out.write(buffer, 0, len);
}
//5，关闭流
in.close();
out.close();
}
//方式1： 采用基本的流，一次一个字节的方式复制
private static void method1(String src, String dest) throws
IOException {
//1，指定数据源
FileInputStream in = new FileInputStream(src);
//2，指定目的地
FileOutputStream out = new FileOutputStream(dest);
//3，读数据
int ch = -1;
while (( ch=in.read()) != -1) {
//4，写数据
out.write(ch);
}
//5，关闭流
in.close();
out.close();
}
}

---

三、字符缓冲流

3.1、字符缓冲流

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

完成文本数据的搞笑的写入和读取操作

3.2、字符缓冲输出流：BufferedWriter

• 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
• 方法：newLine() 根据当前系统，写入一个换行符

public class BufferedWriterDeno {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\实训\\Demo\\src\\test\\abc.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        for(int i = 0;i < 5 ;i++){
            bw.write("Hello xiaolei  ");
            bw.newLine();
        }
        bw.close();
    }
}

3.3、字符缓冲输入流：BufferedReader

• 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
• 方法：readLine() 根据当前系统，写入一个换行符

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:\\实训\\Demo\\src\\test\\abc.txt"));
        String line = null;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
    }
}

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

public class CopyTextFile {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader("D:\\实训\\Demo\\src\\test\\abc.txt"));
        BufferedWriter out = new BufferedWriter(new FileWriter("D:\\实训\\Demo\\src\\test\\COPYabcTest.txt"));
        String line = null;
        while((line = in.readLine())!=null){
            out.write(line);
            out.newLine();
        }
        in.close();
        out.close();
    }
}

---

四、流的操作规律

1、明确要操作的数据是数据源，还是数据目的

• 数据源：InputStream或Reader
• 数据目的：OutputStream或Writer

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

   数据源：

• 字节：InputStream 
• 文本：Reader

   数据目的：

• 字节：OutputStream
• 文本：Writer

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

   源设备：

• 硬盘：文件、File开头
• 内存：数组、字符串
• 键盘：System.in
• 网络：Socket

   目的设备：

• 硬盘：文件、File开头
• 内存：数组、字符串
• 键盘：System.out
• 网络：Socket

4、明确是否需要额外功能

     额外功能：

• 是否需要转换？  转换流。  InputStreamReader， OutputStreamWriter
• 高效？  缓冲区对象。 BufferedXxx